output
stringlengths
349
2.81k
prompt
stringclasses
6 values
input
stringlengths
330
2.5k
instruction
stringclasses
1 value
#include <iostream> using namespace std; int main() { int l, n; cin >> l >> n; int mi = 0, ma = 0; int cur; for (int i = 0; i < n; i++) { cin >> cur; // 更新cur的时候向左的计算出错 mi = max(mi, min(cur, l - cur + 1)); ma = max(ma, max(cur, l - cur + 1)); } cout << mi << " " << ma; return 0; }
这里是题目描述:# 独木桥 ## 题目背景 战争已经进入到紧要时间。你是运输小队长,正在率领运输部队向前线运送物资。运输任务像做题一样的无聊。你希望找些刺激,于是命令你的士兵们到前方的一座独木桥上欣赏风景,而你留在桥下欣赏士兵们。士兵们十分愤怒,因为这座独木桥十分狭窄,只能容纳 $1$ 个人通过。假如有 $2$ 个人相向而行在桥上相遇,那么他们 $2$ 个人将无法绕过对方,只能有 $1$ 个人回头下桥,让另一个人先通过。但是,可以有多个人同时呆在同一个位置。 ## 题目描述 突然,你收到从指挥部发来的信息,敌军的轰炸机正朝着你所在的独木桥飞来!为了安全,你的部队必须撤下独木桥。独木桥的长度为 $L$,士兵们只能呆在坐标为整数的地方。所有士兵的速度都为 $1$,但一个士兵某一时刻来到了坐标为 $0$ 或 $L+1$ 的位置,他就离开了独木桥。 每个士兵都有一个初始面对的方向,他们会以匀速朝着这个方向行走,中途不会自己改变方向。但是,如果两个士兵面对面相遇,他们无法彼此通过对方,于是就分别转身,继续行走。转身不需要任何的时间。 由于先前的愤怒,你已不能控制你的士兵。甚至,你连每个士兵初始面对的方向都不知道。因此,你想要知道你的部队最少需要多少时间就可能全部撤离独木桥。另外,总部也在安排阻拦敌人的进攻,因此你还需要知道你的部队最多需要多少时间才能全部撤离独木桥。 ## 输入格式 第一行共一个整数 $L$,表示独木桥的长度。桥上的坐标为 $1, 2, \cdots, L$。 第二行共一个整数 $N$,表示初始时留在桥上的士兵数目。 第三行共有 $N$ 个整数,分别表示每个士兵的初始坐标。 ## 输出格式 共一行,输出 $2$ 个整数,分别表示部队撤离独木桥的最小时间和最大时间。$2$ 个整数由一个空格符分开。 ## 样例 #1 ### 样例输入 #1 ``` 4 2 1 3 ``` ### 样例输出 #1 ``` 2 4 ``` ## 提示 对于 $100\%$ 的数据,满足初始时,没有两个士兵同在一个坐标,$1\le L\le5\times 10^3$,$0\le N\le5\times10^3$,且数据保证 $N\le L$。 下面是题目解析和做法:此题可以用排序做(高档一点的模拟) 核心思想:两个人相遇转身,相当于交换灵魂后继续走 最大值:最靠近端点两个人各自向对方走,时间较长的那个人的时间 最小值:所有人中走完桥最小值中的最大值 详细见代码: ```cpp #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;algorithm&gt; using namespace std; const int size = 5005; int a[size]; int main() { int L,N; cin&gt;&gt;L&gt;&gt;N; if (!N) //特判 N==0的情况 { cout&lt;&lt;&quot;0 0&quot;&lt;&lt;endl; return 0; } for (int i=1;i&lt;=N;i++) cin&gt;&gt;a[i]; //输入 sort(a+1,a+N+1); //从小到大排序(算最长时间时可能方便一些) int max_time,min_time; for (int i=1;i&lt;=N;i++) min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值 max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走, //时间较长的那个人的时间 (排序的好处) cout&lt;&lt;min_time&lt;&lt;&#039; &#039;&lt;&lt;max_time&lt;&lt;endl; return 0; } ``` 题目标签:排序 结论
#include <iostream> using namespace std; int main() { int l, n; cin >> l >> n; int mi = 0, ma = 0; int cur; for (int i = 0; i < n; i++) { cin >> cur; mi = max(mi, min(cur + 1, l - cur + 1)); ma = max(ma, max(cur + 1, l - cur + 1)); } cout << mi << " " << ma; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; // ---------------------------------------------------------------------------------------------------------- // #define int long long #define ps push #define pb push_back #define PII pair<int, int> #define PDD pair<double, double> #define PSI pair<string, int> #define PIS pair<int, string> #define STI stack<int> #define STS stack<string> #define mm memset #define EPS 1e-8 #define INF 0x7fffffff // #define x first // #define y second #define rep(i, a, n) for (int i = a; i < n; i++) #define per(i, a, n) for (int i = n - 1; i >= a; i--) #define all(x) (x).begin(), (x).end() #define endl "\n" #define bl cout << "------------\n"; typedef long long LL; // ---------------------------------------------------------------------------------------------------------- inline int read() { int x = 0, w = 1; char ch = 0; while (ch < '0' || ch > '9') { // ch 不是数字时 if (ch == '-') w = -1; // 判断是否为负 ch = getchar(); // 继续读入 } while (ch >= '0' && ch <= '9') { // ch 是数字时 x = x * 10 + (ch - '0'); // 将新读入的数字「加」在 x 的后面 // x 是 int 类型,char 类型的 ch 和 '0' 会被自动转为其对应的 // ASCII 码,相当于将 ch 转化为对应数字 // 此处也可以使用 (x<<3)+(x<<1) 的写法来代替 x*10 ch = getchar(); // 继续读入 } return x * w; // 数字 * 正负号 = 实际数值 } inline void write(int x) { static int sta[35]; int top = 0; do { sta[top++] = x % 10, x /= 10; } while (x); while (top) putchar(sta[--top] + 48); // 48 是 '0' } inline int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); } inline int lcm(int a, int b) { return a * b / gcd(a, b); } // ---------------------------------------------------------------------------------------------------------- const int N = 1e5 + 15; int L; int n; int a[N]; void solve() { cin >> L; cin >> n; for (int i = 1; i <= n; i++) cin >> a[i]; int ma = 0, mi = 0; for (int i = 1; i <= n; i++) { // 修改maa和mii更新方式 int mii = min(abs(a[i] - 0), abs(a[i] - (L + 1))); int maa = max(abs(a[i] - 0), abs(a[i] - (L + 1))); ma = max(ma, maa); mi = max(mi, mii); } // 更新输出 cout << mi << " " << ma << endl; } int main() { ios::sync_with_stdio(0); cin.tie(0), cout.tie(0); int T; // cin >> T; T = 1; while (T--) { solve(); } }
这里是题目描述:# 独木桥 ## 题目背景 战争已经进入到紧要时间。你是运输小队长,正在率领运输部队向前线运送物资。运输任务像做题一样的无聊。你希望找些刺激,于是命令你的士兵们到前方的一座独木桥上欣赏风景,而你留在桥下欣赏士兵们。士兵们十分愤怒,因为这座独木桥十分狭窄,只能容纳 $1$ 个人通过。假如有 $2$ 个人相向而行在桥上相遇,那么他们 $2$ 个人将无法绕过对方,只能有 $1$ 个人回头下桥,让另一个人先通过。但是,可以有多个人同时呆在同一个位置。 ## 题目描述 突然,你收到从指挥部发来的信息,敌军的轰炸机正朝着你所在的独木桥飞来!为了安全,你的部队必须撤下独木桥。独木桥的长度为 $L$,士兵们只能呆在坐标为整数的地方。所有士兵的速度都为 $1$,但一个士兵某一时刻来到了坐标为 $0$ 或 $L+1$ 的位置,他就离开了独木桥。 每个士兵都有一个初始面对的方向,他们会以匀速朝着这个方向行走,中途不会自己改变方向。但是,如果两个士兵面对面相遇,他们无法彼此通过对方,于是就分别转身,继续行走。转身不需要任何的时间。 由于先前的愤怒,你已不能控制你的士兵。甚至,你连每个士兵初始面对的方向都不知道。因此,你想要知道你的部队最少需要多少时间就可能全部撤离独木桥。另外,总部也在安排阻拦敌人的进攻,因此你还需要知道你的部队最多需要多少时间才能全部撤离独木桥。 ## 输入格式 第一行共一个整数 $L$,表示独木桥的长度。桥上的坐标为 $1, 2, \cdots, L$。 第二行共一个整数 $N$,表示初始时留在桥上的士兵数目。 第三行共有 $N$ 个整数,分别表示每个士兵的初始坐标。 ## 输出格式 共一行,输出 $2$ 个整数,分别表示部队撤离独木桥的最小时间和最大时间。$2$ 个整数由一个空格符分开。 ## 样例 #1 ### 样例输入 #1 ``` 4 2 1 3 ``` ### 样例输出 #1 ``` 2 4 ``` ## 提示 对于 $100\%$ 的数据,满足初始时,没有两个士兵同在一个坐标,$1\le L\le5\times 10^3$,$0\le N\le5\times10^3$,且数据保证 $N\le L$。 下面是题目解析和做法:此题可以用排序做(高档一点的模拟) 核心思想:两个人相遇转身,相当于交换灵魂后继续走 最大值:最靠近端点两个人各自向对方走,时间较长的那个人的时间 最小值:所有人中走完桥最小值中的最大值 详细见代码: ```cpp #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;algorithm&gt; using namespace std; const int size = 5005; int a[size]; int main() { int L,N; cin&gt;&gt;L&gt;&gt;N; if (!N) //特判 N==0的情况 { cout&lt;&lt;&quot;0 0&quot;&lt;&lt;endl; return 0; } for (int i=1;i&lt;=N;i++) cin&gt;&gt;a[i]; //输入 sort(a+1,a+N+1); //从小到大排序(算最长时间时可能方便一些) int max_time,min_time; for (int i=1;i&lt;=N;i++) min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值 max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走, //时间较长的那个人的时间 (排序的好处) cout&lt;&lt;min_time&lt;&lt;&#039; &#039;&lt;&lt;max_time&lt;&lt;endl; return 0; } ``` 题目标签:排序 结论
#include <bits/stdc++.h> using namespace std; // ---------------------------------------------------------------------------------------------------------- // #define int long long #define ps push #define pb push_back #define PII pair<int, int> #define PDD pair<double, double> #define PSI pair<string, int> #define PIS pair<int, string> #define STI stack<int> #define STS stack<string> #define mm memset #define EPS 1e-8 #define INF 0x7fffffff // #define x first // #define y second #define rep(i, a, n) for (int i = a; i < n; i++) #define per(i, a, n) for (int i = n - 1; i >= a; i--) #define all(x) (x).begin(), (x).end() #define endl "\n" #define bl cout << "------------\n"; typedef long long LL; // ---------------------------------------------------------------------------------------------------------- inline int read() { int x = 0, w = 1; char ch = 0; while (ch < '0' || ch > '9') { // ch 不是数字时 if (ch == '-') w = -1; // 判断是否为负 ch = getchar(); // 继续读入 } while (ch >= '0' && ch <= '9') { // ch 是数字时 x = x * 10 + (ch - '0'); // 将新读入的数字「加」在 x 的后面 // x 是 int 类型,char 类型的 ch 和 '0' 会被自动转为其对应的 // ASCII 码,相当于将 ch 转化为对应数字 // 此处也可以使用 (x<<3)+(x<<1) 的写法来代替 x*10 ch = getchar(); // 继续读入 } return x * w; // 数字 * 正负号 = 实际数值 } inline void write(int x) { static int sta[35]; int top = 0; do { sta[top++] = x % 10, x /= 10; } while (x); while (top) putchar(sta[--top] + 48); // 48 是 '0' } inline int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); } inline int lcm(int a, int b) { return a * b / gcd(a, b); } // ---------------------------------------------------------------------------------------------------------- const int N = 1e5 + 15; int L; int n; int a[N]; void solve() { cin >> L; cin >> n; for (int i = 1; i <= n; i++) cin >> a[i]; int ma = 0, mi = 0; int maa = 0; for (int i = 1; i <= n; i++) { maa = max(abs(a[i] - 0), maa); maa = max(abs(a[i] - L), maa); int mii = min(abs(a[i] - 0), abs(a[i] - (L))); // cout <<abs(a[i]-0)<<" "<<abs(a[i]-(L))<<endl; ma += maa; // cout << mii << endl; mi += mii; } cout << mi << " " << maa + 1 << endl; } int main() { ios::sync_with_stdio(0); cin.tie(0), cout.tie(0); int T; // cin >> T; T = 1; while (T--) { solve(); } }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; const int N = 5e3; int a[N]; // int s[N]; int main() { int l, n; cin >> l >> n; for (int i = 1; i <= n; i++) { cin >> a[i]; // 无用代码 // s[i] = s[i - 1] + a[i]; } if (n == 0) { cout << 0 << " " << 0 << endl; return 0; } // 思路错误,重写 // 更新min:使用max(min(两端的距离)) // 更新max:使用max(max(两端的距离)) sort(a + 1, a + n + 1); // 初值 int min_ = 0, max_ = 0; for (int i = 1; i <= n; i++) { min_ = max(min(l - a[i] + 1, a[i]), min_); } // 访问内存,边界条件 if (n) max_ = max(l - a[1] + 1, a[n]); cout << min_ << " " << max_; return 0; }
这里是题目描述:# 独木桥 ## 题目背景 战争已经进入到紧要时间。你是运输小队长,正在率领运输部队向前线运送物资。运输任务像做题一样的无聊。你希望找些刺激,于是命令你的士兵们到前方的一座独木桥上欣赏风景,而你留在桥下欣赏士兵们。士兵们十分愤怒,因为这座独木桥十分狭窄,只能容纳 $1$ 个人通过。假如有 $2$ 个人相向而行在桥上相遇,那么他们 $2$ 个人将无法绕过对方,只能有 $1$ 个人回头下桥,让另一个人先通过。但是,可以有多个人同时呆在同一个位置。 ## 题目描述 突然,你收到从指挥部发来的信息,敌军的轰炸机正朝着你所在的独木桥飞来!为了安全,你的部队必须撤下独木桥。独木桥的长度为 $L$,士兵们只能呆在坐标为整数的地方。所有士兵的速度都为 $1$,但一个士兵某一时刻来到了坐标为 $0$ 或 $L+1$ 的位置,他就离开了独木桥。 每个士兵都有一个初始面对的方向,他们会以匀速朝着这个方向行走,中途不会自己改变方向。但是,如果两个士兵面对面相遇,他们无法彼此通过对方,于是就分别转身,继续行走。转身不需要任何的时间。 由于先前的愤怒,你已不能控制你的士兵。甚至,你连每个士兵初始面对的方向都不知道。因此,你想要知道你的部队最少需要多少时间就可能全部撤离独木桥。另外,总部也在安排阻拦敌人的进攻,因此你还需要知道你的部队最多需要多少时间才能全部撤离独木桥。 ## 输入格式 第一行共一个整数 $L$,表示独木桥的长度。桥上的坐标为 $1, 2, \cdots, L$。 第二行共一个整数 $N$,表示初始时留在桥上的士兵数目。 第三行共有 $N$ 个整数,分别表示每个士兵的初始坐标。 ## 输出格式 共一行,输出 $2$ 个整数,分别表示部队撤离独木桥的最小时间和最大时间。$2$ 个整数由一个空格符分开。 ## 样例 #1 ### 样例输入 #1 ``` 4 2 1 3 ``` ### 样例输出 #1 ``` 2 4 ``` ## 提示 对于 $100\%$ 的数据,满足初始时,没有两个士兵同在一个坐标,$1\le L\le5\times 10^3$,$0\le N\le5\times10^3$,且数据保证 $N\le L$。 下面是题目解析和做法:此题可以用排序做(高档一点的模拟) 核心思想:两个人相遇转身,相当于交换灵魂后继续走 最大值:最靠近端点两个人各自向对方走,时间较长的那个人的时间 最小值:所有人中走完桥最小值中的最大值 详细见代码: ```cpp #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;algorithm&gt; using namespace std; const int size = 5005; int a[size]; int main() { int L,N; cin&gt;&gt;L&gt;&gt;N; if (!N) //特判 N==0的情况 { cout&lt;&lt;&quot;0 0&quot;&lt;&lt;endl; return 0; } for (int i=1;i&lt;=N;i++) cin&gt;&gt;a[i]; //输入 sort(a+1,a+N+1); //从小到大排序(算最长时间时可能方便一些) int max_time,min_time; for (int i=1;i&lt;=N;i++) min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值 max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走, //时间较长的那个人的时间 (排序的好处) cout&lt;&lt;min_time&lt;&lt;&#039; &#039;&lt;&lt;max_time&lt;&lt;endl; return 0; } ``` 题目标签:排序 结论
#include <bits/stdc++.h> using namespace std; const int N = 5e3; int a[N]; int s[N]; int main() { int l, n; cin >> l >> n; for (int i = 1; i <= n; i++) { cin >> a[i]; s[i] = s[i - 1] + a[i]; } if (n == 0) { cout << 0 << " " << 0 << endl; return 0; } int res = 1e9; // min for (int i = 1; i <= n; i++) { if (s[i] + (n - i) * l - (s[n] - s[i]) < res) { res = s[i] + (n - i) * l - (s[n] - s[i]); } } cout << res << endl; if (n == 1) { cout << max(a[1], l - a[1]) << endl; return 0; } else if (n & 1) { // 奇数个 res = 0; for (int i = 2; i <= n; i += 2) { res += a[i] - a[i - 1] + l; } res += a[n]; } else { res = 0; for (int i = 2; i <= n; i += 2) { int t = a[i] + a[i - 1] >> 1; res += a[i] - a[i - 1] + max(l - t, t); } } cout << res << endl; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; int L, n; int sol[N]; int main() { // min_res初值 int min_res = 0, max_res = 0; cin >> L >> n; for (int i = 0; i < n; i++) { cin >> sol[i]; min_res = max(min_res, min(sol[i], L + 1 - sol[i])); } sort(sol, sol + n); // 边界条件 if (n) max_res = max(L + 1 - sol[0], sol[n - 1]); cout << min_res << " " << max_res; return 0; }
这里是题目描述:# 独木桥 ## 题目背景 战争已经进入到紧要时间。你是运输小队长,正在率领运输部队向前线运送物资。运输任务像做题一样的无聊。你希望找些刺激,于是命令你的士兵们到前方的一座独木桥上欣赏风景,而你留在桥下欣赏士兵们。士兵们十分愤怒,因为这座独木桥十分狭窄,只能容纳 $1$ 个人通过。假如有 $2$ 个人相向而行在桥上相遇,那么他们 $2$ 个人将无法绕过对方,只能有 $1$ 个人回头下桥,让另一个人先通过。但是,可以有多个人同时呆在同一个位置。 ## 题目描述 突然,你收到从指挥部发来的信息,敌军的轰炸机正朝着你所在的独木桥飞来!为了安全,你的部队必须撤下独木桥。独木桥的长度为 $L$,士兵们只能呆在坐标为整数的地方。所有士兵的速度都为 $1$,但一个士兵某一时刻来到了坐标为 $0$ 或 $L+1$ 的位置,他就离开了独木桥。 每个士兵都有一个初始面对的方向,他们会以匀速朝着这个方向行走,中途不会自己改变方向。但是,如果两个士兵面对面相遇,他们无法彼此通过对方,于是就分别转身,继续行走。转身不需要任何的时间。 由于先前的愤怒,你已不能控制你的士兵。甚至,你连每个士兵初始面对的方向都不知道。因此,你想要知道你的部队最少需要多少时间就可能全部撤离独木桥。另外,总部也在安排阻拦敌人的进攻,因此你还需要知道你的部队最多需要多少时间才能全部撤离独木桥。 ## 输入格式 第一行共一个整数 $L$,表示独木桥的长度。桥上的坐标为 $1, 2, \cdots, L$。 第二行共一个整数 $N$,表示初始时留在桥上的士兵数目。 第三行共有 $N$ 个整数,分别表示每个士兵的初始坐标。 ## 输出格式 共一行,输出 $2$ 个整数,分别表示部队撤离独木桥的最小时间和最大时间。$2$ 个整数由一个空格符分开。 ## 样例 #1 ### 样例输入 #1 ``` 4 2 1 3 ``` ### 样例输出 #1 ``` 2 4 ``` ## 提示 对于 $100\%$ 的数据,满足初始时,没有两个士兵同在一个坐标,$1\le L\le5\times 10^3$,$0\le N\le5\times10^3$,且数据保证 $N\le L$。 下面是题目解析和做法:此题可以用排序做(高档一点的模拟) 核心思想:两个人相遇转身,相当于交换灵魂后继续走 最大值:最靠近端点两个人各自向对方走,时间较长的那个人的时间 最小值:所有人中走完桥最小值中的最大值 详细见代码: ```cpp #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;algorithm&gt; using namespace std; const int size = 5005; int a[size]; int main() { int L,N; cin&gt;&gt;L&gt;&gt;N; if (!N) //特判 N==0的情况 { cout&lt;&lt;&quot;0 0&quot;&lt;&lt;endl; return 0; } for (int i=1;i&lt;=N;i++) cin&gt;&gt;a[i]; //输入 sort(a+1,a+N+1); //从小到大排序(算最长时间时可能方便一些) int max_time,min_time; for (int i=1;i&lt;=N;i++) min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值 max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走, //时间较长的那个人的时间 (排序的好处) cout&lt;&lt;min_time&lt;&lt;&#039; &#039;&lt;&lt;max_time&lt;&lt;endl; return 0; } ``` 题目标签:排序 结论
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; int L, n; int sol[N]; int main() { int min_res = 1e9, max_res = 0; cin >> L >> n; for (int i = 0; i < n; i++) { cin >> sol[i]; min_res = max(min_res, min(sol[i], L + 1 - sol[i])); } sort(sol, sol + n); max_res = max(L + 1 - sol[0], sol[n - 1]); cout << min_res << " " << max_res; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; int a[N]; int main() { int l; cin >> l; int n; cin >> n; for (int i = 1; i <= n; i++) cin >> a[i]; sort(a + 1, a + n + 1); // 初值 int min_ = 0, max_ = 0; for (int i = 1; i <= n; i++) { min_ = max(min(l - a[i] + 1, a[i]), min_); } // 访问内存,边界条件 if (n) max_ = max(l - a[1] + 1, a[n]); cout << min_ << " " << max_ << endl; return 0; }
这里是题目描述:# 独木桥 ## 题目背景 战争已经进入到紧要时间。你是运输小队长,正在率领运输部队向前线运送物资。运输任务像做题一样的无聊。你希望找些刺激,于是命令你的士兵们到前方的一座独木桥上欣赏风景,而你留在桥下欣赏士兵们。士兵们十分愤怒,因为这座独木桥十分狭窄,只能容纳 $1$ 个人通过。假如有 $2$ 个人相向而行在桥上相遇,那么他们 $2$ 个人将无法绕过对方,只能有 $1$ 个人回头下桥,让另一个人先通过。但是,可以有多个人同时呆在同一个位置。 ## 题目描述 突然,你收到从指挥部发来的信息,敌军的轰炸机正朝着你所在的独木桥飞来!为了安全,你的部队必须撤下独木桥。独木桥的长度为 $L$,士兵们只能呆在坐标为整数的地方。所有士兵的速度都为 $1$,但一个士兵某一时刻来到了坐标为 $0$ 或 $L+1$ 的位置,他就离开了独木桥。 每个士兵都有一个初始面对的方向,他们会以匀速朝着这个方向行走,中途不会自己改变方向。但是,如果两个士兵面对面相遇,他们无法彼此通过对方,于是就分别转身,继续行走。转身不需要任何的时间。 由于先前的愤怒,你已不能控制你的士兵。甚至,你连每个士兵初始面对的方向都不知道。因此,你想要知道你的部队最少需要多少时间就可能全部撤离独木桥。另外,总部也在安排阻拦敌人的进攻,因此你还需要知道你的部队最多需要多少时间才能全部撤离独木桥。 ## 输入格式 第一行共一个整数 $L$,表示独木桥的长度。桥上的坐标为 $1, 2, \cdots, L$。 第二行共一个整数 $N$,表示初始时留在桥上的士兵数目。 第三行共有 $N$ 个整数,分别表示每个士兵的初始坐标。 ## 输出格式 共一行,输出 $2$ 个整数,分别表示部队撤离独木桥的最小时间和最大时间。$2$ 个整数由一个空格符分开。 ## 样例 #1 ### 样例输入 #1 ``` 4 2 1 3 ``` ### 样例输出 #1 ``` 2 4 ``` ## 提示 对于 $100\%$ 的数据,满足初始时,没有两个士兵同在一个坐标,$1\le L\le5\times 10^3$,$0\le N\le5\times10^3$,且数据保证 $N\le L$。 下面是题目解析和做法:此题可以用排序做(高档一点的模拟) 核心思想:两个人相遇转身,相当于交换灵魂后继续走 最大值:最靠近端点两个人各自向对方走,时间较长的那个人的时间 最小值:所有人中走完桥最小值中的最大值 详细见代码: ```cpp #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;algorithm&gt; using namespace std; const int size = 5005; int a[size]; int main() { int L,N; cin&gt;&gt;L&gt;&gt;N; if (!N) //特判 N==0的情况 { cout&lt;&lt;&quot;0 0&quot;&lt;&lt;endl; return 0; } for (int i=1;i&lt;=N;i++) cin&gt;&gt;a[i]; //输入 sort(a+1,a+N+1); //从小到大排序(算最长时间时可能方便一些) int max_time,min_time; for (int i=1;i&lt;=N;i++) min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值 max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走, //时间较长的那个人的时间 (排序的好处) cout&lt;&lt;min_time&lt;&lt;&#039; &#039;&lt;&lt;max_time&lt;&lt;endl; return 0; } ``` 题目标签:排序 结论
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; int a[N]; int main() { int l; cin >> l; int n; cin >> n; for (int i = 1; i <= n; i++) cin >> a[i]; sort(a + 1, a + n + 1); int min_, max_; for (int i = 1; i <= n; i++) { min_ = max(min(l - a[i] + 1, a[i]), min_); } max_ = max(l - a[1] + 1, a[n]); cout << min_ << " " << max_ << endl; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <iostream> using namespace std; const int N = 1e5 + 10; int site[N]; int l, n, maxans = 0, minans = 0; int main() { cin >> l >> n; for (int i = 0; i < n; i++) { scanf("%d", &site[i]); maxans = max(maxans, max(site[i], l + 1 - site[i])); minans = max(minans, min(site[i], l + 1 - site[i])); } cout << minans << " " << maxans; return 0; }
这里是题目描述:# 独木桥 ## 题目背景 战争已经进入到紧要时间。你是运输小队长,正在率领运输部队向前线运送物资。运输任务像做题一样的无聊。你希望找些刺激,于是命令你的士兵们到前方的一座独木桥上欣赏风景,而你留在桥下欣赏士兵们。士兵们十分愤怒,因为这座独木桥十分狭窄,只能容纳 $1$ 个人通过。假如有 $2$ 个人相向而行在桥上相遇,那么他们 $2$ 个人将无法绕过对方,只能有 $1$ 个人回头下桥,让另一个人先通过。但是,可以有多个人同时呆在同一个位置。 ## 题目描述 突然,你收到从指挥部发来的信息,敌军的轰炸机正朝着你所在的独木桥飞来!为了安全,你的部队必须撤下独木桥。独木桥的长度为 $L$,士兵们只能呆在坐标为整数的地方。所有士兵的速度都为 $1$,但一个士兵某一时刻来到了坐标为 $0$ 或 $L+1$ 的位置,他就离开了独木桥。 每个士兵都有一个初始面对的方向,他们会以匀速朝着这个方向行走,中途不会自己改变方向。但是,如果两个士兵面对面相遇,他们无法彼此通过对方,于是就分别转身,继续行走。转身不需要任何的时间。 由于先前的愤怒,你已不能控制你的士兵。甚至,你连每个士兵初始面对的方向都不知道。因此,你想要知道你的部队最少需要多少时间就可能全部撤离独木桥。另外,总部也在安排阻拦敌人的进攻,因此你还需要知道你的部队最多需要多少时间才能全部撤离独木桥。 ## 输入格式 第一行共一个整数 $L$,表示独木桥的长度。桥上的坐标为 $1, 2, \cdots, L$。 第二行共一个整数 $N$,表示初始时留在桥上的士兵数目。 第三行共有 $N$ 个整数,分别表示每个士兵的初始坐标。 ## 输出格式 共一行,输出 $2$ 个整数,分别表示部队撤离独木桥的最小时间和最大时间。$2$ 个整数由一个空格符分开。 ## 样例 #1 ### 样例输入 #1 ``` 4 2 1 3 ``` ### 样例输出 #1 ``` 2 4 ``` ## 提示 对于 $100\%$ 的数据,满足初始时,没有两个士兵同在一个坐标,$1\le L\le5\times 10^3$,$0\le N\le5\times10^3$,且数据保证 $N\le L$。 下面是题目解析和做法:此题可以用排序做(高档一点的模拟) 核心思想:两个人相遇转身,相当于交换灵魂后继续走 最大值:最靠近端点两个人各自向对方走,时间较长的那个人的时间 最小值:所有人中走完桥最小值中的最大值 详细见代码: ```cpp #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;algorithm&gt; using namespace std; const int size = 5005; int a[size]; int main() { int L,N; cin&gt;&gt;L&gt;&gt;N; if (!N) //特判 N==0的情况 { cout&lt;&lt;&quot;0 0&quot;&lt;&lt;endl; return 0; } for (int i=1;i&lt;=N;i++) cin&gt;&gt;a[i]; //输入 sort(a+1,a+N+1); //从小到大排序(算最长时间时可能方便一些) int max_time,min_time; for (int i=1;i&lt;=N;i++) min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值 max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走, //时间较长的那个人的时间 (排序的好处) cout&lt;&lt;min_time&lt;&lt;&#039; &#039;&lt;&lt;max_time&lt;&lt;endl; return 0; } ``` 题目标签:排序 结论
#include <iostream> using namespace std; const int N = 1e5 + 10; int site[N]; int l, n, maxans = 0, minans = 0; int main() { cin >> l >> n; for (int i = 0; i < n; i++) { scanf("%d", &site[i]); maxans = max(maxans, max(site[i], l + 1 - site[i])); minans = max(minans, min(site[i], l + 1 - site[i])); } cout << maxans << " " << minans; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <iostream> #include <algorithm> #include <cmath> using namespace std; const int M = 5e3 + 4; typedef long long ll; ll m[M]; int main() { ll L; cin >> L; ll n; cin >> n; for (int i = 1; i <= n; i++) { cin >> m[i]; } sort(m + 1, m + 1 + n); ll minx = 0; for (int i = 1; i <= n; i++) { minx = max(min(m[i], L - m[i] + 1), minx); } ll maxx = 0; if (n >= 1) { maxx = max(m[n], L - m[1] + 1); } cout << minx << " " << maxx << endl; return 0; }
这里是题目描述:# 独木桥 ## 题目背景 战争已经进入到紧要时间。你是运输小队长,正在率领运输部队向前线运送物资。运输任务像做题一样的无聊。你希望找些刺激,于是命令你的士兵们到前方的一座独木桥上欣赏风景,而你留在桥下欣赏士兵们。士兵们十分愤怒,因为这座独木桥十分狭窄,只能容纳 $1$ 个人通过。假如有 $2$ 个人相向而行在桥上相遇,那么他们 $2$ 个人将无法绕过对方,只能有 $1$ 个人回头下桥,让另一个人先通过。但是,可以有多个人同时呆在同一个位置。 ## 题目描述 突然,你收到从指挥部发来的信息,敌军的轰炸机正朝着你所在的独木桥飞来!为了安全,你的部队必须撤下独木桥。独木桥的长度为 $L$,士兵们只能呆在坐标为整数的地方。所有士兵的速度都为 $1$,但一个士兵某一时刻来到了坐标为 $0$ 或 $L+1$ 的位置,他就离开了独木桥。 每个士兵都有一个初始面对的方向,他们会以匀速朝着这个方向行走,中途不会自己改变方向。但是,如果两个士兵面对面相遇,他们无法彼此通过对方,于是就分别转身,继续行走。转身不需要任何的时间。 由于先前的愤怒,你已不能控制你的士兵。甚至,你连每个士兵初始面对的方向都不知道。因此,你想要知道你的部队最少需要多少时间就可能全部撤离独木桥。另外,总部也在安排阻拦敌人的进攻,因此你还需要知道你的部队最多需要多少时间才能全部撤离独木桥。 ## 输入格式 第一行共一个整数 $L$,表示独木桥的长度。桥上的坐标为 $1, 2, \cdots, L$。 第二行共一个整数 $N$,表示初始时留在桥上的士兵数目。 第三行共有 $N$ 个整数,分别表示每个士兵的初始坐标。 ## 输出格式 共一行,输出 $2$ 个整数,分别表示部队撤离独木桥的最小时间和最大时间。$2$ 个整数由一个空格符分开。 ## 样例 #1 ### 样例输入 #1 ``` 4 2 1 3 ``` ### 样例输出 #1 ``` 2 4 ``` ## 提示 对于 $100\%$ 的数据,满足初始时,没有两个士兵同在一个坐标,$1\le L\le5\times 10^3$,$0\le N\le5\times10^3$,且数据保证 $N\le L$。 下面是题目解析和做法:此题可以用排序做(高档一点的模拟) 核心思想:两个人相遇转身,相当于交换灵魂后继续走 最大值:最靠近端点两个人各自向对方走,时间较长的那个人的时间 最小值:所有人中走完桥最小值中的最大值 详细见代码: ```cpp #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;algorithm&gt; using namespace std; const int size = 5005; int a[size]; int main() { int L,N; cin&gt;&gt;L&gt;&gt;N; if (!N) //特判 N==0的情况 { cout&lt;&lt;&quot;0 0&quot;&lt;&lt;endl; return 0; } for (int i=1;i&lt;=N;i++) cin&gt;&gt;a[i]; //输入 sort(a+1,a+N+1); //从小到大排序(算最长时间时可能方便一些) int max_time,min_time; for (int i=1;i&lt;=N;i++) min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值 max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走, //时间较长的那个人的时间 (排序的好处) cout&lt;&lt;min_time&lt;&lt;&#039; &#039;&lt;&lt;max_time&lt;&lt;endl; return 0; } ``` 题目标签:排序 结论
#include <iostream> #include <cmath> using namespace std; const int M = 5e3 + 4; typedef long long ll; ll m[M]; int main() { ll L; cin >> L; ll n; cin >> n; for (int i = 1; i <= n; i++) { cin >> m[i]; } ll minx = 0; ll p = n; for (int i = 1; i <= p; i++) { minx += min(m[i], L - m[p]); if (m[i] > L - m[p]) { p--; i--; } } ll maxx = 0; p = n; for (int i = 1; i <= p; i++) { maxx += max(m[i], L - m[p]); if (m[i] < L - m[p]) { p--; i--; } } cout << minx << " " << maxx << endl; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; #define ll int bool cmp(pair<ll, ll> &p, pair<ll, ll> &q) { return p.first < q.first; } int main() { ll n, k; cin >> n >> k; k = n - k; vector<pair<ll, ll>> books(n + 1); for (ll i = 1; i <= n; i++) cin >> books[i].first >> books[i].second; sort(books.begin() + 1, books.begin() + n + 1, cmp); vector<vector<ll>> dp(n + 1, vector<ll>(k + 1, 0)); ll ans = INT_MAX; for (ll i = 2; i <= n; i++) { for (ll j = 2; j <= min(i, k); j++) { dp[i][j] = INT_MAX; for (ll h = j - 1; h < i; h++) dp[i][j] = min(dp[i][j], dp[h][j - 1] + abs(books[i].second - books[h].second)); } } for (ll i = k; i <= n; i++) ans = min(ans, dp[i][k]); cout << ans << endl; return 0; }
这里是题目描述:# 书本整理 ## 题目描述 Frank 是一个非常喜爱整洁的人。他有一大堆书和一个书架,想要把书放在书架上。书架可以放下所有的书,所以 Frank 首先将书按高度顺序排列在书架上。但是 Frank 发现,由于很多书的宽度不同,所以书看起来还是非常不整齐。于是他决定从中拿掉k本书,使得书架可以看起来整齐一点。 书架的不整齐度是这样定义的:每两本书宽度的差的绝对值的和。例如有 $4$ 本书: $1 \times 2$ $5 \times 3$ $2 \times 4$ $3 \times 1$ 那么 Frank 将其排列整齐后是: $1 \times 2$ $2 \times 4$ $3 \times 1$ $5 \times 3$ 不整齐度就是 $2+3+2=7$。 已知每本书的高度都不一样,请你求出去掉 $k$ 本书后的最小的不整齐度。 ## 输入格式 第一行两个数字 $n$ 和 $k$,代表书有几本,从中去掉几本($1 \le n \le 100, 1 \le k<n$)。 下面的 $n$ 行,每行两个数字表示一本书的高度和宽度,均小于等于 $200$。 保证高度不重复 ## 输出格式 一行一个整数,表示书架的最小不整齐度。 ## 样例 #1 ### 样例输入 #1 ``` 4 1 1 2 2 4 3 1 5 3 ``` ### 样例输出 #1 ``` 3 ``` 下面是题目解析和做法:## 先理解题意 对于给出的书本,`Frank`会先把它们按照高度排好序,接下来通过删去一些书本来达到宽度最整齐;不论怎么删去,都是在原有顺序的基础上抽走。 ## 为我这种DP初学者的详细分析 (以下的“差”指的是差的绝对值) “抽走”对于整齐度的影响是很奇怪的:减去自己与两旁书本宽度的差,再加上那两书本宽度的差。尽量转化为已学的模型:**从 $n$ 本书里面挑出 $n-k$ 本,按原顺序排列达到宽度最整齐。** 这是不是很熟悉?如果不,我们一本本地尝试加入,那么**“当前试着把哪一本加入”就是状态的一个维度**(至少要用 $f[i]$)。一步步推导出状态转移方程。 ___ 取第一本,不用花费(花费即增加“不整齐度”)。 ___ 第二本书, 1. 假如自顾自,成为一长串书本的队首(也就是忽略第一本,从第二本开始取),不用花费。 2. 可是如果接上第一本,要花费,好处是队列长度增加到 $2$ 了。发现了吗?**队列长度也是某个维度**(至少要用 $f[i][l]$)。 ___ 到第三本书, 1. 如果忽略前两本,不用花费,但是只取了这么一本书。$f[3][1] = 0$。 2. **如果从第一本或第二本接上,长度都会变成2,那么我们选择花费小的一种方式。$f[3][2] = min( f[1][1] + abs (a[3].w - a[1].w), f[2][1] + abs(a[3].w - a[2].w) )$。** ③:如果前两本都接上,队列成为 $1,2,3$。 ___ 尝试加入第四本书, 1. 也可以从自己开始取,$f[4][1] = 0$。 2. 也可以从 $1$ 或 $2$ 或 $3$ 其中一本接上,长度都会变成 $2$,择优。 3. 也可以从长度为 $2$ 的队列接上^,择优。 4. 也可以接上 $1,2,3$ 这个长度为 $3$ 的队列。 ^**此时前三本中花费最小、长度为2的队列已经存储在 $f[2][2]$ 和 $f[3][2]$,为什么不直接用一个 $f[2]$ 存储?因为第四本与 $2,3$ 两本书相邻的代价是不同的**。不存在 $f[1][2]$,因为取到第一本的时候没有长度为 $2$ 的队列。 ___ 第五本,第六本依此类推。 ```cpp #include &lt;bits/stdc++.h &gt;using namespace std; int n, k, m, Min = 0x7fffffff; int f[501][501]; //f[i][l]:以i作末尾,选了l本书时的最小花费 struct info { int h, w; }a[1001]; bool cmp(const info &amp;x, const info &amp;y) { return x.h &lt;y.h; } int main() { cin &gt;&gt;n &gt;&gt;k; m = n - k;//选取m本书 for(int i = 1; i &lt;= n; i++) scanf(&quot;%d %d &quot;, &amp;a[i].h, &amp;a[i].w); sort(a+1, a+n+1, cmp);//高度决定顺序 memset(f, 20, sizeof(f));//初始极大,能缩小就缩小 for(int i = 1; i &lt;= n; i++) f[i][1] = 0; //单独选择任何书都不会有花费 for(int i = 2; i &lt;= n; i++)//试着放第i本的时候 for(int j = 1; j &lt;= i-1; j++)//尝试与前面第j本相邻 for(int l = 2; l &lt;= min(i, m); l++)//放下第i本时,能从之前长1的队列继承为长2的队列,也能从之前长2的队列继承为长3的队列……l表示放下后的长度 //显然试到第i本时,长度不会超过i,也不会超过m,m是最终需要的长度 f[i][l] = min(f[i][l], f[j][l-1] + abs(a[i].w - a[j].w/*这是尝试相邻的书本*/));//放第i本继承到长度为l,总花费越小越好 for(int i = m; i &lt;= n; i++) Min = min(Min, f[i][m]);//i的循环的意思是:以m结尾的队列,可能最小,以m+1结尾的队列也可能的……以n结尾的队列也可能。 printf(&quot;%d\n &quot;, Min); return 0; } 题目标签:动态规划
#include <bits/stdc++.h> using namespace std; #define ll int bool cmp(pair<ll, ll> &p, pair<ll, ll> &q) { return p.first < q.first; } int main() { ll n, k; cin >> n >> k; k = n - k; vector<pair<ll, ll>> books(n + 1); for (ll i = 1; i <= n; i++) cin >> books[i].first >> books[i].second; sort(books.begin() + 1, books.begin() + n + 1, cmp); vector<vector<ll>> dp(n + 1, vector<ll>(k + 1, 0)); ll ans = INT_MAX; for (ll i = 2; i <= n; i++) { for (ll j = 2; j <= min(i, k); j++) { dp[i][j] = INT_MAX; for (ll h = j - 1; h < i; h++) dp[i][j] = min(dp[i][j], dp[i][j - 1] + abs(books[i].second - books[h].second)); } } for (ll i = k; i <= n; i++) ans = min(ans, dp[i][k]); cout << ans << endl; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> #define all(a) a.begin(), a.end() using namespace std; typedef long long LL; typedef unsigned long long ULL; typedef pair<int, int> PII; const int N = 1e6 + 10; const int M = 4e6 + 10; const int mod = 998244353; const int mod1 = 1e9 + 7; const int inf = 0x3f3f3f3f; const LL INF = 0x3f3f3f3f3f3f3f3f; // const int P=10007; // int dx[]={-1,-1,-1,0,0,1,1,1},dy[]={-1,0,1,-1,1,-1,0,1}; // int dx[]={0,1,-1,0},dy[]={1,0,0,-1}; PII a[N]; int dp[110][110]; void solve() { int n, m; cin >> n >> m; m = n - m; for (int i = 1; i <= n; i++) cin >> a[i].first >> a[i].second; sort(a + 1, a + 1 + n); memset(dp, 0x3f, sizeof dp); for (int i = 1; i <= n; i++) dp[i][1] = 0; for (int i = 2; i <= n; i++) { for (int j = 1; j < i; j++) { for (int k = 2; k <= min(i, m); k++) { dp[i][k] = min(dp[i][k], dp[j][k - 1] + abs(a[i].second - a[j].second)); } } } int ans = 1e9; for (int i = m; i <= n; i++) { ans = min(ans, dp[i][m]); } cout << ans << '\n'; } int main() { // ios::sync_with_stdio(false); // cin.tie(0);cout.tie(0); int t = 1; // cin >> t; while (t--) { solve(); } return 0; }
这里是题目描述:# 书本整理 ## 题目描述 Frank 是一个非常喜爱整洁的人。他有一大堆书和一个书架,想要把书放在书架上。书架可以放下所有的书,所以 Frank 首先将书按高度顺序排列在书架上。但是 Frank 发现,由于很多书的宽度不同,所以书看起来还是非常不整齐。于是他决定从中拿掉k本书,使得书架可以看起来整齐一点。 书架的不整齐度是这样定义的:每两本书宽度的差的绝对值的和。例如有 $4$ 本书: $1 \times 2$ $5 \times 3$ $2 \times 4$ $3 \times 1$ 那么 Frank 将其排列整齐后是: $1 \times 2$ $2 \times 4$ $3 \times 1$ $5 \times 3$ 不整齐度就是 $2+3+2=7$。 已知每本书的高度都不一样,请你求出去掉 $k$ 本书后的最小的不整齐度。 ## 输入格式 第一行两个数字 $n$ 和 $k$,代表书有几本,从中去掉几本($1 \le n \le 100, 1 \le k<n$)。 下面的 $n$ 行,每行两个数字表示一本书的高度和宽度,均小于等于 $200$。 保证高度不重复 ## 输出格式 一行一个整数,表示书架的最小不整齐度。 ## 样例 #1 ### 样例输入 #1 ``` 4 1 1 2 2 4 3 1 5 3 ``` ### 样例输出 #1 ``` 3 ``` 下面是题目解析和做法:## 先理解题意 对于给出的书本,`Frank`会先把它们按照高度排好序,接下来通过删去一些书本来达到宽度最整齐;不论怎么删去,都是在原有顺序的基础上抽走。 ## 为我这种DP初学者的详细分析 (以下的“差”指的是差的绝对值) “抽走”对于整齐度的影响是很奇怪的:减去自己与两旁书本宽度的差,再加上那两书本宽度的差。尽量转化为已学的模型:**从 $n$ 本书里面挑出 $n-k$ 本,按原顺序排列达到宽度最整齐。** 这是不是很熟悉?如果不,我们一本本地尝试加入,那么**“当前试着把哪一本加入”就是状态的一个维度**(至少要用 $f[i]$)。一步步推导出状态转移方程。 ___ 取第一本,不用花费(花费即增加“不整齐度”)。 ___ 第二本书, 1. 假如自顾自,成为一长串书本的队首(也就是忽略第一本,从第二本开始取),不用花费。 2. 可是如果接上第一本,要花费,好处是队列长度增加到 $2$ 了。发现了吗?**队列长度也是某个维度**(至少要用 $f[i][l]$)。 ___ 到第三本书, 1. 如果忽略前两本,不用花费,但是只取了这么一本书。$f[3][1] = 0$。 2. **如果从第一本或第二本接上,长度都会变成2,那么我们选择花费小的一种方式。$f[3][2] = min( f[1][1] + abs (a[3].w - a[1].w), f[2][1] + abs(a[3].w - a[2].w) )$。** ③:如果前两本都接上,队列成为 $1,2,3$。 ___ 尝试加入第四本书, 1. 也可以从自己开始取,$f[4][1] = 0$。 2. 也可以从 $1$ 或 $2$ 或 $3$ 其中一本接上,长度都会变成 $2$,择优。 3. 也可以从长度为 $2$ 的队列接上^,择优。 4. 也可以接上 $1,2,3$ 这个长度为 $3$ 的队列。 ^**此时前三本中花费最小、长度为2的队列已经存储在 $f[2][2]$ 和 $f[3][2]$,为什么不直接用一个 $f[2]$ 存储?因为第四本与 $2,3$ 两本书相邻的代价是不同的**。不存在 $f[1][2]$,因为取到第一本的时候没有长度为 $2$ 的队列。 ___ 第五本,第六本依此类推。 ```cpp #include &lt;bits/stdc++.h &gt;using namespace std; int n, k, m, Min = 0x7fffffff; int f[501][501]; //f[i][l]:以i作末尾,选了l本书时的最小花费 struct info { int h, w; }a[1001]; bool cmp(const info &amp;x, const info &amp;y) { return x.h &lt;y.h; } int main() { cin &gt;&gt;n &gt;&gt;k; m = n - k;//选取m本书 for(int i = 1; i &lt;= n; i++) scanf(&quot;%d %d &quot;, &amp;a[i].h, &amp;a[i].w); sort(a+1, a+n+1, cmp);//高度决定顺序 memset(f, 20, sizeof(f));//初始极大,能缩小就缩小 for(int i = 1; i &lt;= n; i++) f[i][1] = 0; //单独选择任何书都不会有花费 for(int i = 2; i &lt;= n; i++)//试着放第i本的时候 for(int j = 1; j &lt;= i-1; j++)//尝试与前面第j本相邻 for(int l = 2; l &lt;= min(i, m); l++)//放下第i本时,能从之前长1的队列继承为长2的队列,也能从之前长2的队列继承为长3的队列……l表示放下后的长度 //显然试到第i本时,长度不会超过i,也不会超过m,m是最终需要的长度 f[i][l] = min(f[i][l], f[j][l-1] + abs(a[i].w - a[j].w/*这是尝试相邻的书本*/));//放第i本继承到长度为l,总花费越小越好 for(int i = m; i &lt;= n; i++) Min = min(Min, f[i][m]);//i的循环的意思是:以m结尾的队列,可能最小,以m+1结尾的队列也可能的……以n结尾的队列也可能。 printf(&quot;%d\n &quot;, Min); return 0; } 题目标签:动态规划
#include <bits/stdc++.h> #define all(a) a.begin(), a.end() using namespace std; typedef long long LL; typedef unsigned long long ULL; typedef pair<int, int> PII; const int N = 1e6 + 10; const int M = 4e6 + 10; const int mod = 998244353; const int mod1 = 1e9 + 7; const int inf = 0x3f3f3f3f; const LL INF = 0x3f3f3f3f3f3f3f3f; // const int P=10007; // int dx[]={-1,-1,-1,0,0,1,1,1},dy[]={-1,0,1,-1,1,-1,0,1}; // int dx[]={0,1,-1,0},dy[]={1,0,0,-1}; PII a[N]; int dp[110][110]; void solve() { int n, m; cin >> n >> m; for (int i = 1; i <= n; i++) cin >> a[i].first >> a[i].second; sort(a + 1, a + 1 + n); memset(dp, 0x3f, sizeof dp); dp[0][0] = 0, dp[1][0] = 0; for (int i = 1; i <= n; i++) dp[i][i] = dp[i][i - 1] = 0; for (int i = 2; i <= n; i++) dp[i][0] = dp[i - 1][0] + abs(a[i].second - a[i - 1].second); for (int i = 2; i <= n; i++) { for (int k = 1; k <= m; k++) { for (int j = 1; j <= i; j++) { if (j == 1) dp[i][k] = min(dp[i][k], dp[i][k - 1] - abs(a[2].second - a[1].second)); else if (j == i) dp[i][k] = min(dp[i][k], dp[i][k - 1] - abs(a[i].second - a[i - 1].second)); else { dp[i][k] = min(dp[i][k], dp[i][k - 1] - abs(a[j].second - a[j - 1].second) - abs(a[j + 1].second - a[j].second) + abs(a[j + 1].second - a[j - 1].second)); } } } } cout << dp[n][m] << '\n'; } int main() { // ios::sync_with_stdio(false); // cin.tie(0);cout.tie(0); int t = 1; // cin >> t; while (t--) { solve(); } return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> #define endl '\n' #define int long long #define dd double #define INF 0x3f3f3f3f #define msin(a) memset(a, 0, sizeof(a)) #define msax(a) memset(a, INF, sizeof(a)) #define Road_Runner_ \ ios::sync_with_stdio(0); \ cin.tie(0); \ cout.tie(0); using namespace std; int dx[10] = {0, -1, 1, 0, 0, 1, -1, 1, -1}; int dy[10] = {0, 0, 0, -1, 1, 1, -1, -1, 1}; const int N = 205; int lm = 9223372036854775807, im = 2147483647; int T = 1; int n, m, a[N], dp[N][N]; int minn = lm; struct oo { int h; int w; } s[N]; bool cmp(oo x, oo y) { return x.h < y.h; } signed main() { Road_Runner_; cin >> n >> m; for (int i = 1; i <= n; i++) { cin >> s[i].h >> s[i].w; } sort(s + 1, s + 1 + n, cmp); for (int i = 1; i <= n; i++) { a[i] = s[i].w; // cout<<a[i]<<endl; } // dp[i][j]表示以a[i]结尾,去掉了j本书后的最小值 // 一次最多去掉m本书 msax(dp); dp[1][0] = 0; for (int i = 2; i <= n; i++) { dp[i][0] = dp[i - 1][0] + abs(a[i] - a[i - 1]); dp[i][i - 1] = 0; // cout<<i<<" "<<dp[i][0]<<endl; } dp[2][0] = abs(a[2] - a[1]); dp[2][1] = 0; for (int i = 3; i <= n; i++) { // 第i本书为结尾 for (int l = 1; l <= i - 1; l++) { // 之前的第l本书为结尾 for (int j = 0; j <= min(m + i - 1, m); j++) { // 去掉的总本数 for (int k = 0; k <= j; k++) { // 前半段用了k,后半段用了j-k if (j - k + 1 == i - l) { dp[i][j] = min(dp[i][j], dp[l][k] + abs(a[i] - a[l])); if (m - j == n - i) { minn = min(minn, dp[i][j]); } } } } } } cout << minn << endl; return 0; }
这里是题目描述:# 书本整理 ## 题目描述 Frank 是一个非常喜爱整洁的人。他有一大堆书和一个书架,想要把书放在书架上。书架可以放下所有的书,所以 Frank 首先将书按高度顺序排列在书架上。但是 Frank 发现,由于很多书的宽度不同,所以书看起来还是非常不整齐。于是他决定从中拿掉k本书,使得书架可以看起来整齐一点。 书架的不整齐度是这样定义的:每两本书宽度的差的绝对值的和。例如有 $4$ 本书: $1 \times 2$ $5 \times 3$ $2 \times 4$ $3 \times 1$ 那么 Frank 将其排列整齐后是: $1 \times 2$ $2 \times 4$ $3 \times 1$ $5 \times 3$ 不整齐度就是 $2+3+2=7$。 已知每本书的高度都不一样,请你求出去掉 $k$ 本书后的最小的不整齐度。 ## 输入格式 第一行两个数字 $n$ 和 $k$,代表书有几本,从中去掉几本($1 \le n \le 100, 1 \le k<n$)。 下面的 $n$ 行,每行两个数字表示一本书的高度和宽度,均小于等于 $200$。 保证高度不重复 ## 输出格式 一行一个整数,表示书架的最小不整齐度。 ## 样例 #1 ### 样例输入 #1 ``` 4 1 1 2 2 4 3 1 5 3 ``` ### 样例输出 #1 ``` 3 ``` 下面是题目解析和做法:## 先理解题意 对于给出的书本,`Frank`会先把它们按照高度排好序,接下来通过删去一些书本来达到宽度最整齐;不论怎么删去,都是在原有顺序的基础上抽走。 ## 为我这种DP初学者的详细分析 (以下的“差”指的是差的绝对值) “抽走”对于整齐度的影响是很奇怪的:减去自己与两旁书本宽度的差,再加上那两书本宽度的差。尽量转化为已学的模型:**从 $n$ 本书里面挑出 $n-k$ 本,按原顺序排列达到宽度最整齐。** 这是不是很熟悉?如果不,我们一本本地尝试加入,那么**“当前试着把哪一本加入”就是状态的一个维度**(至少要用 $f[i]$)。一步步推导出状态转移方程。 ___ 取第一本,不用花费(花费即增加“不整齐度”)。 ___ 第二本书, 1. 假如自顾自,成为一长串书本的队首(也就是忽略第一本,从第二本开始取),不用花费。 2. 可是如果接上第一本,要花费,好处是队列长度增加到 $2$ 了。发现了吗?**队列长度也是某个维度**(至少要用 $f[i][l]$)。 ___ 到第三本书, 1. 如果忽略前两本,不用花费,但是只取了这么一本书。$f[3][1] = 0$。 2. **如果从第一本或第二本接上,长度都会变成2,那么我们选择花费小的一种方式。$f[3][2] = min( f[1][1] + abs (a[3].w - a[1].w), f[2][1] + abs(a[3].w - a[2].w) )$。** ③:如果前两本都接上,队列成为 $1,2,3$。 ___ 尝试加入第四本书, 1. 也可以从自己开始取,$f[4][1] = 0$。 2. 也可以从 $1$ 或 $2$ 或 $3$ 其中一本接上,长度都会变成 $2$,择优。 3. 也可以从长度为 $2$ 的队列接上^,择优。 4. 也可以接上 $1,2,3$ 这个长度为 $3$ 的队列。 ^**此时前三本中花费最小、长度为2的队列已经存储在 $f[2][2]$ 和 $f[3][2]$,为什么不直接用一个 $f[2]$ 存储?因为第四本与 $2,3$ 两本书相邻的代价是不同的**。不存在 $f[1][2]$,因为取到第一本的时候没有长度为 $2$ 的队列。 ___ 第五本,第六本依此类推。 ```cpp #include &lt;bits/stdc++.h &gt;using namespace std; int n, k, m, Min = 0x7fffffff; int f[501][501]; //f[i][l]:以i作末尾,选了l本书时的最小花费 struct info { int h, w; }a[1001]; bool cmp(const info &amp;x, const info &amp;y) { return x.h &lt;y.h; } int main() { cin &gt;&gt;n &gt;&gt;k; m = n - k;//选取m本书 for(int i = 1; i &lt;= n; i++) scanf(&quot;%d %d &quot;, &amp;a[i].h, &amp;a[i].w); sort(a+1, a+n+1, cmp);//高度决定顺序 memset(f, 20, sizeof(f));//初始极大,能缩小就缩小 for(int i = 1; i &lt;= n; i++) f[i][1] = 0; //单独选择任何书都不会有花费 for(int i = 2; i &lt;= n; i++)//试着放第i本的时候 for(int j = 1; j &lt;= i-1; j++)//尝试与前面第j本相邻 for(int l = 2; l &lt;= min(i, m); l++)//放下第i本时,能从之前长1的队列继承为长2的队列,也能从之前长2的队列继承为长3的队列……l表示放下后的长度 //显然试到第i本时,长度不会超过i,也不会超过m,m是最终需要的长度 f[i][l] = min(f[i][l], f[j][l-1] + abs(a[i].w - a[j].w/*这是尝试相邻的书本*/));//放第i本继承到长度为l,总花费越小越好 for(int i = m; i &lt;= n; i++) Min = min(Min, f[i][m]);//i的循环的意思是:以m结尾的队列,可能最小,以m+1结尾的队列也可能的……以n结尾的队列也可能。 printf(&quot;%d\n &quot;, Min); return 0; } 题目标签:动态规划
#include <bits/stdc++.h> #define endl '\n' #define int long long #define dd double #define INF 0x3f3f3f3f #define msin(a) memset(a, 0, sizeof(a)) #define msax(a) memset(a, INF, sizeof(a)) #define Road_Runner_ \ ios::sync_with_stdio(0); \ cin.tie(0); \ cout.tie(0); using namespace std; int dx[10] = {0, -1, 1, 0, 0, 1, -1, 1, -1}; int dy[10] = {0, 0, 0, -1, 1, 1, -1, -1, 1}; const int N = 205; int lm = 9223372036854775807, im = 2147483647; int T = 1; int n, m, a[N], dp[N][N]; struct oo { int h; int w; } s[N]; bool cmp(oo x, oo y) { return x.h < y.h; } signed main() { Road_Runner_; cin >> n >> m; for (int i = 1; i <= n; i++) { cin >> s[i].h >> s[i].w; } sort(s + 1, s + 1 + n, cmp); for (int i = 1; i <= n; i++) { a[i] = s[i].w; // cout<<a[i]<<endl; } // dp[i][j]表示以a[i]结尾,去掉了j本书后的最小值 // 一次最多去掉m本书 msax(dp); dp[1][0] = 0; for (int i = 2; i <= n; i++) { dp[i][0] = dp[i - 1][0] + abs(a[i] - a[i - 1]); dp[i][i - 1] = 0; // cout<<i<<" "<<dp[i][0]<<endl; } dp[2][0] = abs(a[2] - a[1]); dp[2][1] = 0; for (int i = 3; i <= n; i++) { // 第i本书为结尾 for (int l = 1; l <= i - 1; l++) { // 之前的第l本书为结尾 for (int j = 0; j <= min(l - 1, m); j++) { // 去掉的总本数 for (int k = 0; k <= j; k++) { // 前半段用了k,后半段用了j-k if (j - k + 1 == i - l) { dp[i][j] = min(dp[i][j], dp[l][k] + abs(a[i] - a[l])); } } } } } cout << dp[n][m] << endl; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; #define int long long struct pos { int x, y; } a[110]; int dp[110][110]; bool cmp(pos a1, pos a2) { return a1.x < a2.x; } signed main() { std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); int n, k; cin >> n >> k; for (int i = 1; i <= n; i++) { cin >> a[i].x >> a[i].y; } // 需要增加排序才可以进行后续动态规划 sort(a + 1, a + 1 + n, cmp); int mn = 1e9; memset(dp, 0x3f, sizeof dp); k = n - k; for (int i = 1; i <= n; i++) { dp[i][1] = 0; for (int j = 2; j <= i; j++) { for (int k1 = 1; k1 < i; k1++) { dp[i][j] = min(dp[i][j], dp[k1][j - 1] + abs(a[i].y - a[k1].y)); } } } for (int i = 1; i <= n; i++) mn = min(mn, dp[i][k]); cout << mn << endl; return 0; }
这里是题目描述:# 书本整理 ## 题目描述 Frank 是一个非常喜爱整洁的人。他有一大堆书和一个书架,想要把书放在书架上。书架可以放下所有的书,所以 Frank 首先将书按高度顺序排列在书架上。但是 Frank 发现,由于很多书的宽度不同,所以书看起来还是非常不整齐。于是他决定从中拿掉k本书,使得书架可以看起来整齐一点。 书架的不整齐度是这样定义的:每两本书宽度的差的绝对值的和。例如有 $4$ 本书: $1 \times 2$ $5 \times 3$ $2 \times 4$ $3 \times 1$ 那么 Frank 将其排列整齐后是: $1 \times 2$ $2 \times 4$ $3 \times 1$ $5 \times 3$ 不整齐度就是 $2+3+2=7$。 已知每本书的高度都不一样,请你求出去掉 $k$ 本书后的最小的不整齐度。 ## 输入格式 第一行两个数字 $n$ 和 $k$,代表书有几本,从中去掉几本($1 \le n \le 100, 1 \le k<n$)。 下面的 $n$ 行,每行两个数字表示一本书的高度和宽度,均小于等于 $200$。 保证高度不重复 ## 输出格式 一行一个整数,表示书架的最小不整齐度。 ## 样例 #1 ### 样例输入 #1 ``` 4 1 1 2 2 4 3 1 5 3 ``` ### 样例输出 #1 ``` 3 ``` 下面是题目解析和做法:## 先理解题意 对于给出的书本,`Frank`会先把它们按照高度排好序,接下来通过删去一些书本来达到宽度最整齐;不论怎么删去,都是在原有顺序的基础上抽走。 ## 为我这种DP初学者的详细分析 (以下的“差”指的是差的绝对值) “抽走”对于整齐度的影响是很奇怪的:减去自己与两旁书本宽度的差,再加上那两书本宽度的差。尽量转化为已学的模型:**从 $n$ 本书里面挑出 $n-k$ 本,按原顺序排列达到宽度最整齐。** 这是不是很熟悉?如果不,我们一本本地尝试加入,那么**“当前试着把哪一本加入”就是状态的一个维度**(至少要用 $f[i]$)。一步步推导出状态转移方程。 ___ 取第一本,不用花费(花费即增加“不整齐度”)。 ___ 第二本书, 1. 假如自顾自,成为一长串书本的队首(也就是忽略第一本,从第二本开始取),不用花费。 2. 可是如果接上第一本,要花费,好处是队列长度增加到 $2$ 了。发现了吗?**队列长度也是某个维度**(至少要用 $f[i][l]$)。 ___ 到第三本书, 1. 如果忽略前两本,不用花费,但是只取了这么一本书。$f[3][1] = 0$。 2. **如果从第一本或第二本接上,长度都会变成2,那么我们选择花费小的一种方式。$f[3][2] = min( f[1][1] + abs (a[3].w - a[1].w), f[2][1] + abs(a[3].w - a[2].w) )$。** ③:如果前两本都接上,队列成为 $1,2,3$。 ___ 尝试加入第四本书, 1. 也可以从自己开始取,$f[4][1] = 0$。 2. 也可以从 $1$ 或 $2$ 或 $3$ 其中一本接上,长度都会变成 $2$,择优。 3. 也可以从长度为 $2$ 的队列接上^,择优。 4. 也可以接上 $1,2,3$ 这个长度为 $3$ 的队列。 ^**此时前三本中花费最小、长度为2的队列已经存储在 $f[2][2]$ 和 $f[3][2]$,为什么不直接用一个 $f[2]$ 存储?因为第四本与 $2,3$ 两本书相邻的代价是不同的**。不存在 $f[1][2]$,因为取到第一本的时候没有长度为 $2$ 的队列。 ___ 第五本,第六本依此类推。 ```cpp #include &lt;bits/stdc++.h &gt;using namespace std; int n, k, m, Min = 0x7fffffff; int f[501][501]; //f[i][l]:以i作末尾,选了l本书时的最小花费 struct info { int h, w; }a[1001]; bool cmp(const info &amp;x, const info &amp;y) { return x.h &lt;y.h; } int main() { cin &gt;&gt;n &gt;&gt;k; m = n - k;//选取m本书 for(int i = 1; i &lt;= n; i++) scanf(&quot;%d %d &quot;, &amp;a[i].h, &amp;a[i].w); sort(a+1, a+n+1, cmp);//高度决定顺序 memset(f, 20, sizeof(f));//初始极大,能缩小就缩小 for(int i = 1; i &lt;= n; i++) f[i][1] = 0; //单独选择任何书都不会有花费 for(int i = 2; i &lt;= n; i++)//试着放第i本的时候 for(int j = 1; j &lt;= i-1; j++)//尝试与前面第j本相邻 for(int l = 2; l &lt;= min(i, m); l++)//放下第i本时,能从之前长1的队列继承为长2的队列,也能从之前长2的队列继承为长3的队列……l表示放下后的长度 //显然试到第i本时,长度不会超过i,也不会超过m,m是最终需要的长度 f[i][l] = min(f[i][l], f[j][l-1] + abs(a[i].w - a[j].w/*这是尝试相邻的书本*/));//放第i本继承到长度为l,总花费越小越好 for(int i = m; i &lt;= n; i++) Min = min(Min, f[i][m]);//i的循环的意思是:以m结尾的队列,可能最小,以m+1结尾的队列也可能的……以n结尾的队列也可能。 printf(&quot;%d\n &quot;, Min); return 0; } 题目标签:动态规划
#include <bits/stdc++.h> using namespace std; #define int long long struct pos { int x, y; } a[110]; int dp[110][110]; signed main() { std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); int n, k; cin >> n >> k; for (int i = 1; i <= n; i++) { cin >> a[i].x >> a[i].y; } int mn = 1e9; memset(dp, 0x3f, sizeof dp); k = n - k; for (int i = 1; i <= n; i++) { dp[i][1] = 0; for (int j = 2; j <= i; j++) { for (int k1 = 1; k1 < i; k1++) { dp[i][j] = min(dp[i][j], dp[k1][j - 1] + abs(a[i].y - a[k1].y)); } } } for (int i = 1; i <= n; i++) mn = min(mn, dp[i][k]); cout << mn << endl; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <iostream> #include <algorithm> #include <cstring> using namespace std; int n, k, dp[20000]; struct node { int high, width; } arr[20000]; bool priority(node x, node y) { return x.high < y.high; } int main() { cin >> n >> k; for (int i = 1; i <= n; i++) { cin >> arr[i].high >> arr[i].width; } sort(arr + 1, arr + 1 + n, priority); for (int i = 2; i <= n - k; i++) { for (int j = n; j >= i; j--) { dp[j] = 1e9; for (int l = i - 1; l <= j - 1; l++) { dp[j] = min(dp[j], dp[l] + abs(arr[j].width - arr[l].width)); } } } int ans = 1e9; for (int i = n - k; i <= n; i++) { ans = min(ans, dp[i]); } cout << ans; return 0; }
这里是题目描述:# 书本整理 ## 题目描述 Frank 是一个非常喜爱整洁的人。他有一大堆书和一个书架,想要把书放在书架上。书架可以放下所有的书,所以 Frank 首先将书按高度顺序排列在书架上。但是 Frank 发现,由于很多书的宽度不同,所以书看起来还是非常不整齐。于是他决定从中拿掉k本书,使得书架可以看起来整齐一点。 书架的不整齐度是这样定义的:每两本书宽度的差的绝对值的和。例如有 $4$ 本书: $1 \times 2$ $5 \times 3$ $2 \times 4$ $3 \times 1$ 那么 Frank 将其排列整齐后是: $1 \times 2$ $2 \times 4$ $3 \times 1$ $5 \times 3$ 不整齐度就是 $2+3+2=7$。 已知每本书的高度都不一样,请你求出去掉 $k$ 本书后的最小的不整齐度。 ## 输入格式 第一行两个数字 $n$ 和 $k$,代表书有几本,从中去掉几本($1 \le n \le 100, 1 \le k<n$)。 下面的 $n$ 行,每行两个数字表示一本书的高度和宽度,均小于等于 $200$。 保证高度不重复 ## 输出格式 一行一个整数,表示书架的最小不整齐度。 ## 样例 #1 ### 样例输入 #1 ``` 4 1 1 2 2 4 3 1 5 3 ``` ### 样例输出 #1 ``` 3 ``` 下面是题目解析和做法:## 先理解题意 对于给出的书本,`Frank`会先把它们按照高度排好序,接下来通过删去一些书本来达到宽度最整齐;不论怎么删去,都是在原有顺序的基础上抽走。 ## 为我这种DP初学者的详细分析 (以下的“差”指的是差的绝对值) “抽走”对于整齐度的影响是很奇怪的:减去自己与两旁书本宽度的差,再加上那两书本宽度的差。尽量转化为已学的模型:**从 $n$ 本书里面挑出 $n-k$ 本,按原顺序排列达到宽度最整齐。** 这是不是很熟悉?如果不,我们一本本地尝试加入,那么**“当前试着把哪一本加入”就是状态的一个维度**(至少要用 $f[i]$)。一步步推导出状态转移方程。 ___ 取第一本,不用花费(花费即增加“不整齐度”)。 ___ 第二本书, 1. 假如自顾自,成为一长串书本的队首(也就是忽略第一本,从第二本开始取),不用花费。 2. 可是如果接上第一本,要花费,好处是队列长度增加到 $2$ 了。发现了吗?**队列长度也是某个维度**(至少要用 $f[i][l]$)。 ___ 到第三本书, 1. 如果忽略前两本,不用花费,但是只取了这么一本书。$f[3][1] = 0$。 2. **如果从第一本或第二本接上,长度都会变成2,那么我们选择花费小的一种方式。$f[3][2] = min( f[1][1] + abs (a[3].w - a[1].w), f[2][1] + abs(a[3].w - a[2].w) )$。** ③:如果前两本都接上,队列成为 $1,2,3$。 ___ 尝试加入第四本书, 1. 也可以从自己开始取,$f[4][1] = 0$。 2. 也可以从 $1$ 或 $2$ 或 $3$ 其中一本接上,长度都会变成 $2$,择优。 3. 也可以从长度为 $2$ 的队列接上^,择优。 4. 也可以接上 $1,2,3$ 这个长度为 $3$ 的队列。 ^**此时前三本中花费最小、长度为2的队列已经存储在 $f[2][2]$ 和 $f[3][2]$,为什么不直接用一个 $f[2]$ 存储?因为第四本与 $2,3$ 两本书相邻的代价是不同的**。不存在 $f[1][2]$,因为取到第一本的时候没有长度为 $2$ 的队列。 ___ 第五本,第六本依此类推。 ```cpp #include &lt;bits/stdc++.h &gt;using namespace std; int n, k, m, Min = 0x7fffffff; int f[501][501]; //f[i][l]:以i作末尾,选了l本书时的最小花费 struct info { int h, w; }a[1001]; bool cmp(const info &amp;x, const info &amp;y) { return x.h &lt;y.h; } int main() { cin &gt;&gt;n &gt;&gt;k; m = n - k;//选取m本书 for(int i = 1; i &lt;= n; i++) scanf(&quot;%d %d &quot;, &amp;a[i].h, &amp;a[i].w); sort(a+1, a+n+1, cmp);//高度决定顺序 memset(f, 20, sizeof(f));//初始极大,能缩小就缩小 for(int i = 1; i &lt;= n; i++) f[i][1] = 0; //单独选择任何书都不会有花费 for(int i = 2; i &lt;= n; i++)//试着放第i本的时候 for(int j = 1; j &lt;= i-1; j++)//尝试与前面第j本相邻 for(int l = 2; l &lt;= min(i, m); l++)//放下第i本时,能从之前长1的队列继承为长2的队列,也能从之前长2的队列继承为长3的队列……l表示放下后的长度 //显然试到第i本时,长度不会超过i,也不会超过m,m是最终需要的长度 f[i][l] = min(f[i][l], f[j][l-1] + abs(a[i].w - a[j].w/*这是尝试相邻的书本*/));//放第i本继承到长度为l,总花费越小越好 for(int i = m; i &lt;= n; i++) Min = min(Min, f[i][m]);//i的循环的意思是:以m结尾的队列,可能最小,以m+1结尾的队列也可能的……以n结尾的队列也可能。 printf(&quot;%d\n &quot;, Min); return 0; } 题目标签:动态规划
#include <iostream> #include <algorithm> #include <cstring> using namespace std; int n, k, dp[20000]; struct node { int high, width; } arr[20000]; bool priority(node x, node y) { return x.high < y.high; } int main() { cin >> n >> k; for (int i = 1; i <= n; i++) { cin >> arr[i].high >> arr[i].width; } sort(arr + 1, arr + 1 + n, priority); for (int i = 3; i <= n - k; i++) { for (int j = n; j >= i; j--) { dp[j] = 1e9; for (int l = i - 1; l <= j - 1; l++) { dp[i] = min(dp[j], dp[l] + abs(arr[j].width - arr[l].width)); } } } int ans = 1e9; for (int i = n - k; i <= n; i++) { ans = min(ans, dp[i]); } cout << ans; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; struct book { int h, w; } books[105]; int n, k; int dp[501][501]; int main() { cin >> n >> k; for (int i = 1; i <= n; ++i) { cin >> books[i].h >> books[i].w; } auto cmp = [](const book &lhs, const book &rhs) -> bool { return lhs.h < rhs.h; }; sort(books + 1, books + n + 1, cmp); memset(dp, 0x3f, sizeof(dp)); for (int i = 1; i <= n; ++i) { dp[i][1] = 0; } for (int i = 2; i <= n; ++i) { for (int t = 1; t < i; ++t) { for (int j = 2; j <= i && j <= n - k; ++j) { dp[i][j] = std::min(dp[t][j - 1] + abs(books[t].w - books[i].w), dp[i][j]); } } } int ans = INT_MAX; for (int i = n - k; i <= n; ++i) { ans = std::min(dp[i][n - k], ans); } cout << ans; }
这里是题目描述:# 书本整理 ## 题目描述 Frank 是一个非常喜爱整洁的人。他有一大堆书和一个书架,想要把书放在书架上。书架可以放下所有的书,所以 Frank 首先将书按高度顺序排列在书架上。但是 Frank 发现,由于很多书的宽度不同,所以书看起来还是非常不整齐。于是他决定从中拿掉k本书,使得书架可以看起来整齐一点。 书架的不整齐度是这样定义的:每两本书宽度的差的绝对值的和。例如有 $4$ 本书: $1 \times 2$ $5 \times 3$ $2 \times 4$ $3 \times 1$ 那么 Frank 将其排列整齐后是: $1 \times 2$ $2 \times 4$ $3 \times 1$ $5 \times 3$ 不整齐度就是 $2+3+2=7$。 已知每本书的高度都不一样,请你求出去掉 $k$ 本书后的最小的不整齐度。 ## 输入格式 第一行两个数字 $n$ 和 $k$,代表书有几本,从中去掉几本($1 \le n \le 100, 1 \le k<n$)。 下面的 $n$ 行,每行两个数字表示一本书的高度和宽度,均小于等于 $200$。 保证高度不重复 ## 输出格式 一行一个整数,表示书架的最小不整齐度。 ## 样例 #1 ### 样例输入 #1 ``` 4 1 1 2 2 4 3 1 5 3 ``` ### 样例输出 #1 ``` 3 ``` 下面是题目解析和做法:## 先理解题意 对于给出的书本,`Frank`会先把它们按照高度排好序,接下来通过删去一些书本来达到宽度最整齐;不论怎么删去,都是在原有顺序的基础上抽走。 ## 为我这种DP初学者的详细分析 (以下的“差”指的是差的绝对值) “抽走”对于整齐度的影响是很奇怪的:减去自己与两旁书本宽度的差,再加上那两书本宽度的差。尽量转化为已学的模型:**从 $n$ 本书里面挑出 $n-k$ 本,按原顺序排列达到宽度最整齐。** 这是不是很熟悉?如果不,我们一本本地尝试加入,那么**“当前试着把哪一本加入”就是状态的一个维度**(至少要用 $f[i]$)。一步步推导出状态转移方程。 ___ 取第一本,不用花费(花费即增加“不整齐度”)。 ___ 第二本书, 1. 假如自顾自,成为一长串书本的队首(也就是忽略第一本,从第二本开始取),不用花费。 2. 可是如果接上第一本,要花费,好处是队列长度增加到 $2$ 了。发现了吗?**队列长度也是某个维度**(至少要用 $f[i][l]$)。 ___ 到第三本书, 1. 如果忽略前两本,不用花费,但是只取了这么一本书。$f[3][1] = 0$。 2. **如果从第一本或第二本接上,长度都会变成2,那么我们选择花费小的一种方式。$f[3][2] = min( f[1][1] + abs (a[3].w - a[1].w), f[2][1] + abs(a[3].w - a[2].w) )$。** ③:如果前两本都接上,队列成为 $1,2,3$。 ___ 尝试加入第四本书, 1. 也可以从自己开始取,$f[4][1] = 0$。 2. 也可以从 $1$ 或 $2$ 或 $3$ 其中一本接上,长度都会变成 $2$,择优。 3. 也可以从长度为 $2$ 的队列接上^,择优。 4. 也可以接上 $1,2,3$ 这个长度为 $3$ 的队列。 ^**此时前三本中花费最小、长度为2的队列已经存储在 $f[2][2]$ 和 $f[3][2]$,为什么不直接用一个 $f[2]$ 存储?因为第四本与 $2,3$ 两本书相邻的代价是不同的**。不存在 $f[1][2]$,因为取到第一本的时候没有长度为 $2$ 的队列。 ___ 第五本,第六本依此类推。 ```cpp #include &lt;bits/stdc++.h &gt;using namespace std; int n, k, m, Min = 0x7fffffff; int f[501][501]; //f[i][l]:以i作末尾,选了l本书时的最小花费 struct info { int h, w; }a[1001]; bool cmp(const info &amp;x, const info &amp;y) { return x.h &lt;y.h; } int main() { cin &gt;&gt;n &gt;&gt;k; m = n - k;//选取m本书 for(int i = 1; i &lt;= n; i++) scanf(&quot;%d %d &quot;, &amp;a[i].h, &amp;a[i].w); sort(a+1, a+n+1, cmp);//高度决定顺序 memset(f, 20, sizeof(f));//初始极大,能缩小就缩小 for(int i = 1; i &lt;= n; i++) f[i][1] = 0; //单独选择任何书都不会有花费 for(int i = 2; i &lt;= n; i++)//试着放第i本的时候 for(int j = 1; j &lt;= i-1; j++)//尝试与前面第j本相邻 for(int l = 2; l &lt;= min(i, m); l++)//放下第i本时,能从之前长1的队列继承为长2的队列,也能从之前长2的队列继承为长3的队列……l表示放下后的长度 //显然试到第i本时,长度不会超过i,也不会超过m,m是最终需要的长度 f[i][l] = min(f[i][l], f[j][l-1] + abs(a[i].w - a[j].w/*这是尝试相邻的书本*/));//放第i本继承到长度为l,总花费越小越好 for(int i = m; i &lt;= n; i++) Min = min(Min, f[i][m]);//i的循环的意思是:以m结尾的队列,可能最小,以m+1结尾的队列也可能的……以n结尾的队列也可能。 printf(&quot;%d\n &quot;, Min); return 0; } 题目标签:动态规划
#include <bits/stdc++.h> using namespace std; struct book { int h, w; } books[105]; int n, k; int dp[501][501]; int main() { cin >> n >> k; for (int i = 1; i <= n; ++i) { cin >> books[i].h >> books[i].w; } auto cmp = [](const book &lhs, const book &rhs) -> bool { return lhs.h < rhs.w; }; sort(books + 1, books + n + 1, cmp); memset(dp, 0x3f, sizeof(dp)); for (int i = 1; i <= n; ++i) { dp[i][1] = 0; } for (int i = 2; i <= n; ++i) { for (int t = 1; t < i; ++t) { for (int j = 2; j <= i && j <= n - k; ++j) { dp[i][j] = std::min(dp[t][j - 1] + abs(books[t].w - books[i].w), dp[i][j]); } } } int ans = INT_MAX; for (int i = n - k; i <= n; ++i) { ans = std::min(dp[i][n - k], ans); } cout << ans; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <iostream> #include <string.h> #include <algorithm> #include <stack> #include <vector> using namespace std; struct book { int high; int wide; }; bool cmp(book a1, book a2) { return a1.high < a2.high; } int main() { int n, k; cin >> n >> k; k = n - k; // 转化为在n本书中取k本最整齐的书 book *a = new book[n]; for (int i = 0; i < n; i++) cin >> a[i].high >> a[i].wide; sort(a, a + n, cmp); int **dp = new int *[n]; for (int i = 0; i < n; i++) { dp[i] = new int[k]; dp[i][0] = 0; // 只取1本书不整齐度一定为0 } // dp[i-1][j-1]表示在前i本书中取j本书(且必须取第i本书)所构成的最小不整齐度(i>j>0) for (int i = 1; i < n; i++) for (int j = 1; j <= min(i, k - 1); j++) { dp[i][j] = 0x7fffffff; for (int p = j - 1; p < i; p++) { // dp[p][j - 1]表示前p-1本书中取j-2本书且必须取第p-1本书的最小不整齐度 int add = abs(a[i].wide - a[p].wide); dp[i][j] = min(dp[i][j], dp[p][j - 1] + add); } } int ans = 0x7fffffff; for (int i = k - 1; i < n; i++) ans = min(ans, dp[i][k - 1]); cout << ans; return 0; }
这里是题目描述:# 书本整理 ## 题目描述 Frank 是一个非常喜爱整洁的人。他有一大堆书和一个书架,想要把书放在书架上。书架可以放下所有的书,所以 Frank 首先将书按高度顺序排列在书架上。但是 Frank 发现,由于很多书的宽度不同,所以书看起来还是非常不整齐。于是他决定从中拿掉k本书,使得书架可以看起来整齐一点。 书架的不整齐度是这样定义的:每两本书宽度的差的绝对值的和。例如有 $4$ 本书: $1 \times 2$ $5 \times 3$ $2 \times 4$ $3 \times 1$ 那么 Frank 将其排列整齐后是: $1 \times 2$ $2 \times 4$ $3 \times 1$ $5 \times 3$ 不整齐度就是 $2+3+2=7$。 已知每本书的高度都不一样,请你求出去掉 $k$ 本书后的最小的不整齐度。 ## 输入格式 第一行两个数字 $n$ 和 $k$,代表书有几本,从中去掉几本($1 \le n \le 100, 1 \le k<n$)。 下面的 $n$ 行,每行两个数字表示一本书的高度和宽度,均小于等于 $200$。 保证高度不重复 ## 输出格式 一行一个整数,表示书架的最小不整齐度。 ## 样例 #1 ### 样例输入 #1 ``` 4 1 1 2 2 4 3 1 5 3 ``` ### 样例输出 #1 ``` 3 ``` 下面是题目解析和做法:## 先理解题意 对于给出的书本,`Frank`会先把它们按照高度排好序,接下来通过删去一些书本来达到宽度最整齐;不论怎么删去,都是在原有顺序的基础上抽走。 ## 为我这种DP初学者的详细分析 (以下的“差”指的是差的绝对值) “抽走”对于整齐度的影响是很奇怪的:减去自己与两旁书本宽度的差,再加上那两书本宽度的差。尽量转化为已学的模型:**从 $n$ 本书里面挑出 $n-k$ 本,按原顺序排列达到宽度最整齐。** 这是不是很熟悉?如果不,我们一本本地尝试加入,那么**“当前试着把哪一本加入”就是状态的一个维度**(至少要用 $f[i]$)。一步步推导出状态转移方程。 ___ 取第一本,不用花费(花费即增加“不整齐度”)。 ___ 第二本书, 1. 假如自顾自,成为一长串书本的队首(也就是忽略第一本,从第二本开始取),不用花费。 2. 可是如果接上第一本,要花费,好处是队列长度增加到 $2$ 了。发现了吗?**队列长度也是某个维度**(至少要用 $f[i][l]$)。 ___ 到第三本书, 1. 如果忽略前两本,不用花费,但是只取了这么一本书。$f[3][1] = 0$。 2. **如果从第一本或第二本接上,长度都会变成2,那么我们选择花费小的一种方式。$f[3][2] = min( f[1][1] + abs (a[3].w - a[1].w), f[2][1] + abs(a[3].w - a[2].w) )$。** ③:如果前两本都接上,队列成为 $1,2,3$。 ___ 尝试加入第四本书, 1. 也可以从自己开始取,$f[4][1] = 0$。 2. 也可以从 $1$ 或 $2$ 或 $3$ 其中一本接上,长度都会变成 $2$,择优。 3. 也可以从长度为 $2$ 的队列接上^,择优。 4. 也可以接上 $1,2,3$ 这个长度为 $3$ 的队列。 ^**此时前三本中花费最小、长度为2的队列已经存储在 $f[2][2]$ 和 $f[3][2]$,为什么不直接用一个 $f[2]$ 存储?因为第四本与 $2,3$ 两本书相邻的代价是不同的**。不存在 $f[1][2]$,因为取到第一本的时候没有长度为 $2$ 的队列。 ___ 第五本,第六本依此类推。 ```cpp #include &lt;bits/stdc++.h &gt;using namespace std; int n, k, m, Min = 0x7fffffff; int f[501][501]; //f[i][l]:以i作末尾,选了l本书时的最小花费 struct info { int h, w; }a[1001]; bool cmp(const info &amp;x, const info &amp;y) { return x.h &lt;y.h; } int main() { cin &gt;&gt;n &gt;&gt;k; m = n - k;//选取m本书 for(int i = 1; i &lt;= n; i++) scanf(&quot;%d %d &quot;, &amp;a[i].h, &amp;a[i].w); sort(a+1, a+n+1, cmp);//高度决定顺序 memset(f, 20, sizeof(f));//初始极大,能缩小就缩小 for(int i = 1; i &lt;= n; i++) f[i][1] = 0; //单独选择任何书都不会有花费 for(int i = 2; i &lt;= n; i++)//试着放第i本的时候 for(int j = 1; j &lt;= i-1; j++)//尝试与前面第j本相邻 for(int l = 2; l &lt;= min(i, m); l++)//放下第i本时,能从之前长1的队列继承为长2的队列,也能从之前长2的队列继承为长3的队列……l表示放下后的长度 //显然试到第i本时,长度不会超过i,也不会超过m,m是最终需要的长度 f[i][l] = min(f[i][l], f[j][l-1] + abs(a[i].w - a[j].w/*这是尝试相邻的书本*/));//放第i本继承到长度为l,总花费越小越好 for(int i = m; i &lt;= n; i++) Min = min(Min, f[i][m]);//i的循环的意思是:以m结尾的队列,可能最小,以m+1结尾的队列也可能的……以n结尾的队列也可能。 printf(&quot;%d\n &quot;, Min); return 0; } 题目标签:动态规划
#include <iostream> #include <string.h> #include <algorithm> #include <stack> #include <vector> using namespace std; struct book { int high; int wide; }; bool cmp(book a1, book a2) { return a1.high < a2.high; } int main() { int n, k; cin >> n >> k; k = n - k; // 转化为在n本书中取k本最整齐的书 book *a = new book[n]; for (int i = 0; i < n; i++) cin >> a[i].high >> a[i].wide; // sort(a, a + n, cmp); int **dp = new int *[n]; for (int i = 0; i < n; i++) { dp[i] = new int[k]; dp[i][0] = 0; // 只取1本书不整齐度一定为0 } // dp[i-1][j-1]表示在前i本书中取j本书(且必须取第i本书)所构成的最小不整齐度(i>j>0) for (int i = 1; i < n; i++) for (int j = 1; j <= min(i, k - 1); j++) { dp[i][j] = 0x7fffffff; for (int p = j - 1; p < i; p++) { // dp[p][j - 1]表示前p-1本书中取j-2本书且必须取第p-1本书的最小不整齐度 int add = abs(a[i].wide - a[p].wide); dp[i][j] = min(dp[i][j], dp[p][j - 1] + add); } } int ans = 0x7fffffff; for (int i = k - 1; i < n; i++) ans = min(ans, dp[i][k - 1]); cout << ans; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; const int inf = INT_MAX; int n, m; int a[105], x, f[105][105]; int main() { cin >> n >> m; for (int i = 1; i <= n; i++) { cin >> a[i] >> x; a[i] <<= 18; a[i] += x; } sort(a + 1, a + 1 + n); for (int i = 1; i <= n; i++) a[i] = a[i] & 0x0000FFFF; memset(f, 0x3f, sizeof(f)); for (int i = 0; i <= n; i++) f[i][1] = 0; for (int i = 1; i <= n; i++) for (int j = 1; j <= i; j++) for (int k = j - 1; k <= i - 1; k++) f[i][j] = min(f[i][j], f[k][j - 1] + abs(a[i] - a[k])); int ans = inf; for (int i = n - m; i <= n; i++) ans = min(ans, f[i][n - m]); printf("%d\n", ans); return 0l; }
这里是题目描述:# 书本整理 ## 题目描述 Frank 是一个非常喜爱整洁的人。他有一大堆书和一个书架,想要把书放在书架上。书架可以放下所有的书,所以 Frank 首先将书按高度顺序排列在书架上。但是 Frank 发现,由于很多书的宽度不同,所以书看起来还是非常不整齐。于是他决定从中拿掉k本书,使得书架可以看起来整齐一点。 书架的不整齐度是这样定义的:每两本书宽度的差的绝对值的和。例如有 $4$ 本书: $1 \times 2$ $5 \times 3$ $2 \times 4$ $3 \times 1$ 那么 Frank 将其排列整齐后是: $1 \times 2$ $2 \times 4$ $3 \times 1$ $5 \times 3$ 不整齐度就是 $2+3+2=7$。 已知每本书的高度都不一样,请你求出去掉 $k$ 本书后的最小的不整齐度。 ## 输入格式 第一行两个数字 $n$ 和 $k$,代表书有几本,从中去掉几本($1 \le n \le 100, 1 \le k<n$)。 下面的 $n$ 行,每行两个数字表示一本书的高度和宽度,均小于等于 $200$。 保证高度不重复 ## 输出格式 一行一个整数,表示书架的最小不整齐度。 ## 样例 #1 ### 样例输入 #1 ``` 4 1 1 2 2 4 3 1 5 3 ``` ### 样例输出 #1 ``` 3 ``` 下面是题目解析和做法:## 先理解题意 对于给出的书本,`Frank`会先把它们按照高度排好序,接下来通过删去一些书本来达到宽度最整齐;不论怎么删去,都是在原有顺序的基础上抽走。 ## 为我这种DP初学者的详细分析 (以下的“差”指的是差的绝对值) “抽走”对于整齐度的影响是很奇怪的:减去自己与两旁书本宽度的差,再加上那两书本宽度的差。尽量转化为已学的模型:**从 $n$ 本书里面挑出 $n-k$ 本,按原顺序排列达到宽度最整齐。** 这是不是很熟悉?如果不,我们一本本地尝试加入,那么**“当前试着把哪一本加入”就是状态的一个维度**(至少要用 $f[i]$)。一步步推导出状态转移方程。 ___ 取第一本,不用花费(花费即增加“不整齐度”)。 ___ 第二本书, 1. 假如自顾自,成为一长串书本的队首(也就是忽略第一本,从第二本开始取),不用花费。 2. 可是如果接上第一本,要花费,好处是队列长度增加到 $2$ 了。发现了吗?**队列长度也是某个维度**(至少要用 $f[i][l]$)。 ___ 到第三本书, 1. 如果忽略前两本,不用花费,但是只取了这么一本书。$f[3][1] = 0$。 2. **如果从第一本或第二本接上,长度都会变成2,那么我们选择花费小的一种方式。$f[3][2] = min( f[1][1] + abs (a[3].w - a[1].w), f[2][1] + abs(a[3].w - a[2].w) )$。** ③:如果前两本都接上,队列成为 $1,2,3$。 ___ 尝试加入第四本书, 1. 也可以从自己开始取,$f[4][1] = 0$。 2. 也可以从 $1$ 或 $2$ 或 $3$ 其中一本接上,长度都会变成 $2$,择优。 3. 也可以从长度为 $2$ 的队列接上^,择优。 4. 也可以接上 $1,2,3$ 这个长度为 $3$ 的队列。 ^**此时前三本中花费最小、长度为2的队列已经存储在 $f[2][2]$ 和 $f[3][2]$,为什么不直接用一个 $f[2]$ 存储?因为第四本与 $2,3$ 两本书相邻的代价是不同的**。不存在 $f[1][2]$,因为取到第一本的时候没有长度为 $2$ 的队列。 ___ 第五本,第六本依此类推。 ```cpp #include &lt;bits/stdc++.h &gt;using namespace std; int n, k, m, Min = 0x7fffffff; int f[501][501]; //f[i][l]:以i作末尾,选了l本书时的最小花费 struct info { int h, w; }a[1001]; bool cmp(const info &amp;x, const info &amp;y) { return x.h &lt;y.h; } int main() { cin &gt;&gt;n &gt;&gt;k; m = n - k;//选取m本书 for(int i = 1; i &lt;= n; i++) scanf(&quot;%d %d &quot;, &amp;a[i].h, &amp;a[i].w); sort(a+1, a+n+1, cmp);//高度决定顺序 memset(f, 20, sizeof(f));//初始极大,能缩小就缩小 for(int i = 1; i &lt;= n; i++) f[i][1] = 0; //单独选择任何书都不会有花费 for(int i = 2; i &lt;= n; i++)//试着放第i本的时候 for(int j = 1; j &lt;= i-1; j++)//尝试与前面第j本相邻 for(int l = 2; l &lt;= min(i, m); l++)//放下第i本时,能从之前长1的队列继承为长2的队列,也能从之前长2的队列继承为长3的队列……l表示放下后的长度 //显然试到第i本时,长度不会超过i,也不会超过m,m是最终需要的长度 f[i][l] = min(f[i][l], f[j][l-1] + abs(a[i].w - a[j].w/*这是尝试相邻的书本*/));//放第i本继承到长度为l,总花费越小越好 for(int i = m; i &lt;= n; i++) Min = min(Min, f[i][m]);//i的循环的意思是:以m结尾的队列,可能最小,以m+1结尾的队列也可能的……以n结尾的队列也可能。 printf(&quot;%d\n &quot;, Min); return 0; } 题目标签:动态规划
#include <bits/stdc++.h> using namespace std; const int inf = INT_MAX; int n, m; int a[105], x, f[105][105]; int main() { cin >> n >> m; for (int i = 1; i <= n; i++) { cin >> a[i] >> x; a[i] <<= 18; a[i] += x; } sort(a + 1, a + 1 + n); memset(f, 0x3f, sizeof(f)); for (int i = 0; i <= n; i++) f[i][1] = 0; for (int i = 1; i <= n; i++) for (int j = 1; j <= i; j++) for (int k = j - 1; k <= i - 1; k++) f[i][j] = min(f[i][j], f[k][j - 1] + abs(a[i] - a[k])); int ans = inf; for (int i = n - m; i <= n; i++) ans = min(ans, f[i][n - m]); printf("%d\n", ans); return 0l; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; typedef long long ll; const ll MAXN = 1e2 + 5; ll n, k, dp[MAXN][MAXN][2]; struct node { ll h; ll w; } a[MAXN]; bool cmp(node xx, node yy) { return xx.h < yy.h; } int main() { ios::sync_with_stdio(false); cin >> n >> k; k = n - k; for (int i = 1; i <= n; i++) cin >> a[i].h >> a[i].w; sort(a + 1, a + n + 1, cmp); memset(dp, 0x3f, sizeof dp); for (int i = 1; i <= n; i++) dp[i][1][1] = 0; for (int i = 1; i <= n; i++) { for (int j = 1; j <= k; j++) { dp[i][j][0] = min({dp[i][j][0], dp[i - 1][j][1], dp[i - 1][j][0]}); for (int pwp = 1; pwp <= i - 1; pwp++) { dp[i][j][1] = min(dp[i][j][1], dp[pwp][j - 1][1] + abs(a[i].w - a[pwp].w)); } } } cout << min(dp[n][k][1], dp[n][k][0]) << endl; return 0; }
这里是题目描述:# 书本整理 ## 题目描述 Frank 是一个非常喜爱整洁的人。他有一大堆书和一个书架,想要把书放在书架上。书架可以放下所有的书,所以 Frank 首先将书按高度顺序排列在书架上。但是 Frank 发现,由于很多书的宽度不同,所以书看起来还是非常不整齐。于是他决定从中拿掉k本书,使得书架可以看起来整齐一点。 书架的不整齐度是这样定义的:每两本书宽度的差的绝对值的和。例如有 $4$ 本书: $1 \times 2$ $5 \times 3$ $2 \times 4$ $3 \times 1$ 那么 Frank 将其排列整齐后是: $1 \times 2$ $2 \times 4$ $3 \times 1$ $5 \times 3$ 不整齐度就是 $2+3+2=7$。 已知每本书的高度都不一样,请你求出去掉 $k$ 本书后的最小的不整齐度。 ## 输入格式 第一行两个数字 $n$ 和 $k$,代表书有几本,从中去掉几本($1 \le n \le 100, 1 \le k<n$)。 下面的 $n$ 行,每行两个数字表示一本书的高度和宽度,均小于等于 $200$。 保证高度不重复 ## 输出格式 一行一个整数,表示书架的最小不整齐度。 ## 样例 #1 ### 样例输入 #1 ``` 4 1 1 2 2 4 3 1 5 3 ``` ### 样例输出 #1 ``` 3 ``` 下面是题目解析和做法:## 先理解题意 对于给出的书本,`Frank`会先把它们按照高度排好序,接下来通过删去一些书本来达到宽度最整齐;不论怎么删去,都是在原有顺序的基础上抽走。 ## 为我这种DP初学者的详细分析 (以下的“差”指的是差的绝对值) “抽走”对于整齐度的影响是很奇怪的:减去自己与两旁书本宽度的差,再加上那两书本宽度的差。尽量转化为已学的模型:**从 $n$ 本书里面挑出 $n-k$ 本,按原顺序排列达到宽度最整齐。** 这是不是很熟悉?如果不,我们一本本地尝试加入,那么**“当前试着把哪一本加入”就是状态的一个维度**(至少要用 $f[i]$)。一步步推导出状态转移方程。 ___ 取第一本,不用花费(花费即增加“不整齐度”)。 ___ 第二本书, 1. 假如自顾自,成为一长串书本的队首(也就是忽略第一本,从第二本开始取),不用花费。 2. 可是如果接上第一本,要花费,好处是队列长度增加到 $2$ 了。发现了吗?**队列长度也是某个维度**(至少要用 $f[i][l]$)。 ___ 到第三本书, 1. 如果忽略前两本,不用花费,但是只取了这么一本书。$f[3][1] = 0$。 2. **如果从第一本或第二本接上,长度都会变成2,那么我们选择花费小的一种方式。$f[3][2] = min( f[1][1] + abs (a[3].w - a[1].w), f[2][1] + abs(a[3].w - a[2].w) )$。** ③:如果前两本都接上,队列成为 $1,2,3$。 ___ 尝试加入第四本书, 1. 也可以从自己开始取,$f[4][1] = 0$。 2. 也可以从 $1$ 或 $2$ 或 $3$ 其中一本接上,长度都会变成 $2$,择优。 3. 也可以从长度为 $2$ 的队列接上^,择优。 4. 也可以接上 $1,2,3$ 这个长度为 $3$ 的队列。 ^**此时前三本中花费最小、长度为2的队列已经存储在 $f[2][2]$ 和 $f[3][2]$,为什么不直接用一个 $f[2]$ 存储?因为第四本与 $2,3$ 两本书相邻的代价是不同的**。不存在 $f[1][2]$,因为取到第一本的时候没有长度为 $2$ 的队列。 ___ 第五本,第六本依此类推。 ```cpp #include &lt;bits/stdc++.h &gt;using namespace std; int n, k, m, Min = 0x7fffffff; int f[501][501]; //f[i][l]:以i作末尾,选了l本书时的最小花费 struct info { int h, w; }a[1001]; bool cmp(const info &amp;x, const info &amp;y) { return x.h &lt;y.h; } int main() { cin &gt;&gt;n &gt;&gt;k; m = n - k;//选取m本书 for(int i = 1; i &lt;= n; i++) scanf(&quot;%d %d &quot;, &amp;a[i].h, &amp;a[i].w); sort(a+1, a+n+1, cmp);//高度决定顺序 memset(f, 20, sizeof(f));//初始极大,能缩小就缩小 for(int i = 1; i &lt;= n; i++) f[i][1] = 0; //单独选择任何书都不会有花费 for(int i = 2; i &lt;= n; i++)//试着放第i本的时候 for(int j = 1; j &lt;= i-1; j++)//尝试与前面第j本相邻 for(int l = 2; l &lt;= min(i, m); l++)//放下第i本时,能从之前长1的队列继承为长2的队列,也能从之前长2的队列继承为长3的队列……l表示放下后的长度 //显然试到第i本时,长度不会超过i,也不会超过m,m是最终需要的长度 f[i][l] = min(f[i][l], f[j][l-1] + abs(a[i].w - a[j].w/*这是尝试相邻的书本*/));//放第i本继承到长度为l,总花费越小越好 for(int i = m; i &lt;= n; i++) Min = min(Min, f[i][m]);//i的循环的意思是:以m结尾的队列,可能最小,以m+1结尾的队列也可能的……以n结尾的队列也可能。 printf(&quot;%d\n &quot;, Min); return 0; } 题目标签:动态规划
#include <bits/stdc++.h> using namespace std; typedef long long ll; const ll MAXN = 1e2 + 5; ll n, k, dp[MAXN][MAXN]; struct node { ll h; ll w; } a[MAXN]; bool cmp(node xx, node yy) { return xx.h < yy.h; } int main() { ios::sync_with_stdio(false); cin >> n >> k; k = n - k; for (int i = 1; i <= n; i++) cin >> a[i].h >> a[i].w; sort(a + 1, a + n + 1, cmp); memset(dp, 0x3f, sizeof dp); for (int i = 1; i <= n; i++) dp[i][1] = 0; for (int i = 1; i <= n; i++) { for (int j = 1; j <= k; j++) { for (int pwp = 1; pwp <= i - 1; pwp++) { dp[i][j] = min({dp[i][j], dp[i - 1][j], dp[pwp][j - 1] + abs(a[i].w - a[pwp].w)}); } } } cout << dp[n][k] << endl; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <iostream> #include <map> #include <string> using namespace std; struct node { string s; } f[12][12]; map<string, int> mp; bool vis[12]; int is = 0; int main() { int n; cin >> n; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { cin >> f[i][j].s; } } for (int i = 2; i <= n; i++) { string t = f[i][1].s; int cnt = 0; for (int j = 1; j <= n; j++) { if (f[i][j].s.size() == 2) { cnt++; } } mp.insert({t, cnt}); vis[cnt] = true; } for (int i = 0; i <= n - 2; i++) { if (!vis[i]) { is = 1; break; } } if (is == 1) { cout << "ERROR!" << endl; } else { int pp = 0; for (int i = 2; i <= n; i++) { for (int j = 2; j <= n; j++) { int t1 = mp[f[i][1].s]; int t2 = mp[f[1][j].s]; int t; if (f[i][j].s.size() == 2) { string s1; string s2; s1 += f[i][j].s[0]; s2 += f[i][j].s[1]; t = mp[s1] * n - 1 + mp[s2]; } else { t = mp[f[i][j].s]; } if (t != t1 + t2) { pp = 1; break; } } if (pp == 1) { break; } } if (pp == 1) { cout << "ERROR!" << endl; } else { for (int i = 2; i <= n; i++) { if (i != n) { cout << f[i][1].s << "=" << mp[f[i][1].s] << " "; } else { cout << f[i][1].s << "=" << mp[f[i][1].s] << endl; } } cout << n - 1 << endl; } } }
这里是题目描述:# [NOIP1998 提高组] 进制位 ## 题目描述 著名科学家卢斯为了检查学生对进位制的理解,他给出了如下的一张加法表,表中的字母代表数字。 例如: $$ \def\arraystretch{2} \begin{array}{c||c|c|c|c} \rm + & \kern{.5cm} \rm \mathclap{L} \kern{.5cm} & \kern{.5cm} \rm \mathclap{K} \kern{.5cm} & \kern{.5cm} \rm \mathclap{V} \kern{.5cm} & \kern{.5cm} \rm \mathclap{E} \kern{.5cm} \\ \hline\hline \rm L & \rm L & \rm K & \rm V & \rm E \\ \hline \rm K & \rm K & \rm V & \rm E & \rm \mathclap{KL} \\ \hline \rm V & \rm V & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} \\ \hline \rm E & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} & \rm \mathclap{KV} \\ \end{array}$$ 其含义为: $L+L=L$,$L+K=K$,$L+V=V$,$L+E=E$ $K+L=K$,$K+K=V$,$K+V=E$,$K+E=KL$ $\cdots$ $E+E=KV$ 根据这些规则可推导出:$L=0$,$K=1$,$V=2$,$E=3$。 同时可以确定该表表示的是 $4$ 进制加法。 ## 输入格式 第一行一个整数 $n$($3\le n\le9$)表示行数。 以下 $n$ 行,每行包括 $n$ 个字符串,每个字符串间用空格隔开。) 若记 $s_{i,j}$ 表示第 $i$ 行第 $j$ 个字符串,数据保证 $s_{1,1}=\texttt +$,$s_{i,1}=s_{1,i}$,$|s_{i,1}|=1$,$s_{i,1}\ne s_{j,1}$ ($i\ne j$)。 保证至多有一组解。 ## 输出格式 第一行输出各个字母表示什么数,格式如:`L=0 K=1` $\cdots$ 按给出的字母顺序排序。不同字母必须代表不同数字。 第二行输出加法运算是几进制的。 若不可能组成加法表,则应输出 `ERROR!`。 ## 样例 #1 ### 样例输入 #1 ``` 5 + L K V E L L K V E K K V E KL V V E KL KK E E KL KK KV ``` ### 样例输出 #1 ``` L=0 K=1 V=2 E=3 4 ``` ## 提示 NOIP1998 提高组 第三题 下面是题目解析和做法:## 题意 给出一个加法表,一个字母代表一个数字。求加法的进制,以及每个大写字母代表的数字。 数字个数 $N\le 8$ 。(行数 $\le 9$) ## 题解 结论: 1. 一定是 $N$ 进制。 2. 每一行有几个二位数,这个数就是几。 --- 证明: 因为有 $N$ 个不同的数,所以最少 $N$ 进制。 假设为 $N+1$ 进制,那么一定有一个数没有出现,假设为 $k$ 。 1. $k=0$ 或 $k=1$,而 $1+N=10$ ,矛盾。 2. $1 &lt; k \le N$ ,而 $1+(k-1)=k$ ,矛盾。 其它 $&gt; N$ 进制的情况同理,所以一定是 $N$ 进制,结论 $1$ 得证。 数字为 $0..N-1$ ,所以结论 $2$ 显然。 --- 有上面的结论后这道题就很好做了。每个数的值都可以预处理出来,记为 $ans[]$ ;同时把字母与数字的对应关系记为 $mp[]$ 。 然后枚举每个数,检验有没有矛盾,如果有就直接输出 `ERROR` 。最后把 $ans[]$ 全部输出即可。 ```cpp #include<bits/stdc++.h> using namespace std; inline int read() { char ch=getchar(); int f=1,x=0; while (ch<'0' || ch>'9') { if (ch=='-') f=-1; ch=getchar(); } while (ch>='0' && ch<='9') { x=x*10+ch-'0'; ch=getchar(); } return f*x; } int n,ans[15],mp[26]; char s[15][15][3]; inline bool check(int x,int y) //检验 (x,y) { int sum=ans[x]+ans[y]; //和 int cur=s[x][y][1]-'A'; //处理十位 if (sum>=n-1 && mp[cur]!=1) return 0; //如果和 >=n-1 但没有进位 if (sum>=n-1) sum-=n-1,cur=s[x][y][2]-'A'; //处理个位 if (mp[cur]!=sum) return 0; //不相等 return 1; } signed main() { n=read(); for (int j=1;j<=n;j++) scanf("%s",s[1][j]+1); for (int i=2;i<=n;i++) { int cnt=0; for (int j=1;j<=n;j++) { scanf("%s",s[i][j]+1); cnt+=strlen(s[i][j]+1)>=2; } ans[i]=cnt; mp[s[i][1][1]-'A']=cnt; } for (int i=2;i<=n;i++) for (int j=2;j<=n;j++) if (!check(i,j)) return 0&puts("ERROR!"); for (int i=2;i<=n;i++) printf("%c=%d ",s[i][1][1],ans[i]); return !printf("\n%d",n-1); } ``` 题目标签:搜索
#include <iostream> #include <map> #include <string> using namespace std; struct node { string s; } f[12][12]; map<string, int> mp; bool vis[12]; int is = 0; int main() { int n; cin >> n; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { cin >> f[i][j].s; } } for (int i = 2; i <= n; i++) { string t = f[i][1].s; int cnt = 0; for (int j = 1; j <= n; j++) { if (f[i][j].s.size() == 2) { cnt++; } } mp.insert({t, cnt}); vis[cnt] = true; } for (int i = 0; i <= n - 2; i++) { if (!vis[i]) { is = 1; break; } } if (is == 1) { cout << "ERROR!" << endl; } else { int pp = 0; for (int i = 2; i <= n; i++) { for (int j = 2; j <= n; j++) { int t1 = mp[f[i][1].s]; int t2 = mp[f[1][j].s]; int t = mp[f[i][j].s]; if (t != t1 + t2) { pp = 1; break; } } if (pp == 1) { break; } } if (pp == 1) { cout << "ERROR!" << endl; } else { for (int i = 2; i <= n; i++) { if (i != n) { cout << f[i][1].s << "=" << mp[f[i][1].s] << " "; } else { cout << f[i][1].s << "=" << mp[f[i][1].s] << endl; } } cout << n - 1 << endl; } } }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; int n, m[100], p[15]; string s[15][15]; int main() { cin >> n; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) cin >> s[i][j]; } for (int i = 1; i < n; ++i) { int sum = 0; for (int j = 1; j < n; ++j) sum += (s[i][j].size() == 2); p[i] = sum; m[s[i][0][0]] = sum; } for (int i = 1; i < n; ++i) { for (int j = 1; j < n; ++j) { int a = p[i], b = p[j], c = m[s[i][j][0]]; if (s[i][j].size() == 2) c = c * (n - 1) + m[s[i][j][1]]; if (c != a + b) { cout << "ERROR!"; return 0; } } } for (int i = 1; i < n; ++i) cout << s[i][0] << '=' << p[i] << ' '; cout << '\n' << --n; return 0; }
这里是题目描述:# [NOIP1998 提高组] 进制位 ## 题目描述 著名科学家卢斯为了检查学生对进位制的理解,他给出了如下的一张加法表,表中的字母代表数字。 例如: $$ \def\arraystretch{2} \begin{array}{c||c|c|c|c} \rm + & \kern{.5cm} \rm \mathclap{L} \kern{.5cm} & \kern{.5cm} \rm \mathclap{K} \kern{.5cm} & \kern{.5cm} \rm \mathclap{V} \kern{.5cm} & \kern{.5cm} \rm \mathclap{E} \kern{.5cm} \\ \hline\hline \rm L & \rm L & \rm K & \rm V & \rm E \\ \hline \rm K & \rm K & \rm V & \rm E & \rm \mathclap{KL} \\ \hline \rm V & \rm V & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} \\ \hline \rm E & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} & \rm \mathclap{KV} \\ \end{array}$$ 其含义为: $L+L=L$,$L+K=K$,$L+V=V$,$L+E=E$ $K+L=K$,$K+K=V$,$K+V=E$,$K+E=KL$ $\cdots$ $E+E=KV$ 根据这些规则可推导出:$L=0$,$K=1$,$V=2$,$E=3$。 同时可以确定该表表示的是 $4$ 进制加法。 ## 输入格式 第一行一个整数 $n$($3\le n\le9$)表示行数。 以下 $n$ 行,每行包括 $n$ 个字符串,每个字符串间用空格隔开。) 若记 $s_{i,j}$ 表示第 $i$ 行第 $j$ 个字符串,数据保证 $s_{1,1}=\texttt +$,$s_{i,1}=s_{1,i}$,$|s_{i,1}|=1$,$s_{i,1}\ne s_{j,1}$ ($i\ne j$)。 保证至多有一组解。 ## 输出格式 第一行输出各个字母表示什么数,格式如:`L=0 K=1` $\cdots$ 按给出的字母顺序排序。不同字母必须代表不同数字。 第二行输出加法运算是几进制的。 若不可能组成加法表,则应输出 `ERROR!`。 ## 样例 #1 ### 样例输入 #1 ``` 5 + L K V E L L K V E K K V E KL V V E KL KK E E KL KK KV ``` ### 样例输出 #1 ``` L=0 K=1 V=2 E=3 4 ``` ## 提示 NOIP1998 提高组 第三题 下面是题目解析和做法:## 题意 给出一个加法表,一个字母代表一个数字。求加法的进制,以及每个大写字母代表的数字。 数字个数 $N\le 8$ 。(行数 $\le 9$) ## 题解 结论: 1. 一定是 $N$ 进制。 2. 每一行有几个二位数,这个数就是几。 --- 证明: 因为有 $N$ 个不同的数,所以最少 $N$ 进制。 假设为 $N+1$ 进制,那么一定有一个数没有出现,假设为 $k$ 。 1. $k=0$ 或 $k=1$,而 $1+N=10$ ,矛盾。 2. $1 &lt; k \le N$ ,而 $1+(k-1)=k$ ,矛盾。 其它 $&gt; N$ 进制的情况同理,所以一定是 $N$ 进制,结论 $1$ 得证。 数字为 $0..N-1$ ,所以结论 $2$ 显然。 --- 有上面的结论后这道题就很好做了。每个数的值都可以预处理出来,记为 $ans[]$ ;同时把字母与数字的对应关系记为 $mp[]$ 。 然后枚举每个数,检验有没有矛盾,如果有就直接输出 `ERROR` 。最后把 $ans[]$ 全部输出即可。 ```cpp #include<bits/stdc++.h> using namespace std; inline int read() { char ch=getchar(); int f=1,x=0; while (ch<'0' || ch>'9') { if (ch=='-') f=-1; ch=getchar(); } while (ch>='0' && ch<='9') { x=x*10+ch-'0'; ch=getchar(); } return f*x; } int n,ans[15],mp[26]; char s[15][15][3]; inline bool check(int x,int y) //检验 (x,y) { int sum=ans[x]+ans[y]; //和 int cur=s[x][y][1]-'A'; //处理十位 if (sum>=n-1 && mp[cur]!=1) return 0; //如果和 >=n-1 但没有进位 if (sum>=n-1) sum-=n-1,cur=s[x][y][2]-'A'; //处理个位 if (mp[cur]!=sum) return 0; //不相等 return 1; } signed main() { n=read(); for (int j=1;j<=n;j++) scanf("%s",s[1][j]+1); for (int i=2;i<=n;i++) { int cnt=0; for (int j=1;j<=n;j++) { scanf("%s",s[i][j]+1); cnt+=strlen(s[i][j]+1)>=2; } ans[i]=cnt; mp[s[i][1][1]-'A']=cnt; } for (int i=2;i<=n;i++) for (int j=2;j<=n;j++) if (!check(i,j)) return 0&puts("ERROR!"); for (int i=2;i<=n;i++) printf("%c=%d ",s[i][1][1],ans[i]); return !printf("\n%d",n-1); } ``` 题目标签:搜索
#include <bits/stdc++.h> using namespace std; int n, m[100], p[15]; string s[15][15]; int main() { cin >> n; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) cin >> s[i][j]; } for (int i = 1; i < n; ++i) { int sum = 0; for (int j = 1; j < n; ++j) sum += (s[i][j].size() == 2); p[i] = sum; m[s[i][0][0]] = sum; } for (int i = 1; i < n; ++i) { for (int j = 1; j < n; ++j) { int a = p[i], b = p[j], c = m[s[i][j][0]]; if (s[i][j].size() == 2) c = c * (n - 1) + m[s[i][j][1]]; if (c != a + b) { cout << "ERROR!"; return 0; } } } for (int i = 1; i < n; ++i) cout << s[i][1] << '=' << p[i] << ' '; cout << '\n' << --n; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; int n, m[100], p[15]; string s[15][15]; int main() { cin >> n; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) cin >> s[i][j]; } for (int i = 1; i < n; ++i) { int sum = 0; for (int j = 1; j < n; ++j) sum += (s[i][j].size() == 2); p[i] = sum; m[s[i][0][0]] = sum; } for (int i = 1; i < n; ++i) { for (int j = i; j < n; ++j) { int a = p[i], b = p[j], c = m[s[i][j][0]]; if (s[i][j].size() == 2) c = c * (n - 1) + m[s[i][j][1]]; if (c != a + b) { cout << "ERROR!"; return 0; } } } for (int i = 1; i < n; ++i) cout << s[i][0] << '=' << p[i] << ' '; cout << '\n' << --n; return 0; }
这里是题目描述:# [NOIP1998 提高组] 进制位 ## 题目描述 著名科学家卢斯为了检查学生对进位制的理解,他给出了如下的一张加法表,表中的字母代表数字。 例如: $$ \def\arraystretch{2} \begin{array}{c||c|c|c|c} \rm + & \kern{.5cm} \rm \mathclap{L} \kern{.5cm} & \kern{.5cm} \rm \mathclap{K} \kern{.5cm} & \kern{.5cm} \rm \mathclap{V} \kern{.5cm} & \kern{.5cm} \rm \mathclap{E} \kern{.5cm} \\ \hline\hline \rm L & \rm L & \rm K & \rm V & \rm E \\ \hline \rm K & \rm K & \rm V & \rm E & \rm \mathclap{KL} \\ \hline \rm V & \rm V & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} \\ \hline \rm E & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} & \rm \mathclap{KV} \\ \end{array}$$ 其含义为: $L+L=L$,$L+K=K$,$L+V=V$,$L+E=E$ $K+L=K$,$K+K=V$,$K+V=E$,$K+E=KL$ $\cdots$ $E+E=KV$ 根据这些规则可推导出:$L=0$,$K=1$,$V=2$,$E=3$。 同时可以确定该表表示的是 $4$ 进制加法。 ## 输入格式 第一行一个整数 $n$($3\le n\le9$)表示行数。 以下 $n$ 行,每行包括 $n$ 个字符串,每个字符串间用空格隔开。) 若记 $s_{i,j}$ 表示第 $i$ 行第 $j$ 个字符串,数据保证 $s_{1,1}=\texttt +$,$s_{i,1}=s_{1,i}$,$|s_{i,1}|=1$,$s_{i,1}\ne s_{j,1}$ ($i\ne j$)。 保证至多有一组解。 ## 输出格式 第一行输出各个字母表示什么数,格式如:`L=0 K=1` $\cdots$ 按给出的字母顺序排序。不同字母必须代表不同数字。 第二行输出加法运算是几进制的。 若不可能组成加法表,则应输出 `ERROR!`。 ## 样例 #1 ### 样例输入 #1 ``` 5 + L K V E L L K V E K K V E KL V V E KL KK E E KL KK KV ``` ### 样例输出 #1 ``` L=0 K=1 V=2 E=3 4 ``` ## 提示 NOIP1998 提高组 第三题 下面是题目解析和做法:## 题意 给出一个加法表,一个字母代表一个数字。求加法的进制,以及每个大写字母代表的数字。 数字个数 $N\le 8$ 。(行数 $\le 9$) ## 题解 结论: 1. 一定是 $N$ 进制。 2. 每一行有几个二位数,这个数就是几。 --- 证明: 因为有 $N$ 个不同的数,所以最少 $N$ 进制。 假设为 $N+1$ 进制,那么一定有一个数没有出现,假设为 $k$ 。 1. $k=0$ 或 $k=1$,而 $1+N=10$ ,矛盾。 2. $1 &lt; k \le N$ ,而 $1+(k-1)=k$ ,矛盾。 其它 $&gt; N$ 进制的情况同理,所以一定是 $N$ 进制,结论 $1$ 得证。 数字为 $0..N-1$ ,所以结论 $2$ 显然。 --- 有上面的结论后这道题就很好做了。每个数的值都可以预处理出来,记为 $ans[]$ ;同时把字母与数字的对应关系记为 $mp[]$ 。 然后枚举每个数,检验有没有矛盾,如果有就直接输出 `ERROR` 。最后把 $ans[]$ 全部输出即可。 ```cpp #include<bits/stdc++.h> using namespace std; inline int read() { char ch=getchar(); int f=1,x=0; while (ch<'0' || ch>'9') { if (ch=='-') f=-1; ch=getchar(); } while (ch>='0' && ch<='9') { x=x*10+ch-'0'; ch=getchar(); } return f*x; } int n,ans[15],mp[26]; char s[15][15][3]; inline bool check(int x,int y) //检验 (x,y) { int sum=ans[x]+ans[y]; //和 int cur=s[x][y][1]-'A'; //处理十位 if (sum>=n-1 && mp[cur]!=1) return 0; //如果和 >=n-1 但没有进位 if (sum>=n-1) sum-=n-1,cur=s[x][y][2]-'A'; //处理个位 if (mp[cur]!=sum) return 0; //不相等 return 1; } signed main() { n=read(); for (int j=1;j<=n;j++) scanf("%s",s[1][j]+1); for (int i=2;i<=n;i++) { int cnt=0; for (int j=1;j<=n;j++) { scanf("%s",s[i][j]+1); cnt+=strlen(s[i][j]+1)>=2; } ans[i]=cnt; mp[s[i][1][1]-'A']=cnt; } for (int i=2;i<=n;i++) for (int j=2;j<=n;j++) if (!check(i,j)) return 0&puts("ERROR!"); for (int i=2;i<=n;i++) printf("%c=%d ",s[i][1][1],ans[i]); return !printf("\n%d",n-1); } ``` 题目标签:搜索
#include <bits/stdc++.h> using namespace std; int n, m[100], p[15]; string s[15][15]; int main() { cin >> n; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) cin >> s[i][j]; } for (int i = 1; i < n; ++i) { int sum = 0; for (int j = 1; j < n; ++j) sum += (s[i][j].size() == 2); p[i] = sum; m[s[i][0][0]] = sum; } for (int i = 1; i < n; ++i) { for (int j = i + 1; j < n; ++j) { int a = p[i], b = p[j], c = m[s[i][j][0]]; if (s[i][j].size() == 2) c = c * (n - 1) + m[s[i][j][1]]; if (c != a + b) { cout << "ERROR!"; return 0; } } } for (int i = 1; i < n; ++i) cout << s[i][0] << '=' << p[i] << ' '; cout << '\n' << --n; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <iostream> #include <map> #define MAXN 10 using namespace std; using i64 [[maybe_unused]] = long long; string arr[MAXN][MAXN]; int ans[MAXN]; map<int, string> m; signed main() { #ifdef LOCAL freopen("test.in", "r", stdin); freopen("test.out", "w", stdout); #endif int n; cin >> n; for (int j = 0; j < n; ++j) { cin >> arr[0][j]; } for (int i = 1; i < n; ++i) { int cnt = 0; for (int j = 0; j < n; ++j) { cin >> arr[i][j]; if (arr[i][j].length() > 1) cnt++; } ans[i] = cnt; m[cnt] = arr[0][i]; } for (int i = 1; i < n; ++i) { for (int j = 1; j < n; ++j) { string s; int p = ans[i] + ans[j]; if (p >= n - 1) { p -= n - 1; s += m[1]; } s += m[p]; if (s != arr[i][j]) { cout << "ERROR!" << endl; return 0; } } } for (int i = 1; i < n; ++i) { cout << arr[0][i] << "=" << ans[i] << " "; } cout << endl << n - 1 << endl; return 0; }
这里是题目描述:# [NOIP1998 提高组] 进制位 ## 题目描述 著名科学家卢斯为了检查学生对进位制的理解,他给出了如下的一张加法表,表中的字母代表数字。 例如: $$ \def\arraystretch{2} \begin{array}{c||c|c|c|c} \rm + & \kern{.5cm} \rm \mathclap{L} \kern{.5cm} & \kern{.5cm} \rm \mathclap{K} \kern{.5cm} & \kern{.5cm} \rm \mathclap{V} \kern{.5cm} & \kern{.5cm} \rm \mathclap{E} \kern{.5cm} \\ \hline\hline \rm L & \rm L & \rm K & \rm V & \rm E \\ \hline \rm K & \rm K & \rm V & \rm E & \rm \mathclap{KL} \\ \hline \rm V & \rm V & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} \\ \hline \rm E & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} & \rm \mathclap{KV} \\ \end{array}$$ 其含义为: $L+L=L$,$L+K=K$,$L+V=V$,$L+E=E$ $K+L=K$,$K+K=V$,$K+V=E$,$K+E=KL$ $\cdots$ $E+E=KV$ 根据这些规则可推导出:$L=0$,$K=1$,$V=2$,$E=3$。 同时可以确定该表表示的是 $4$ 进制加法。 ## 输入格式 第一行一个整数 $n$($3\le n\le9$)表示行数。 以下 $n$ 行,每行包括 $n$ 个字符串,每个字符串间用空格隔开。) 若记 $s_{i,j}$ 表示第 $i$ 行第 $j$ 个字符串,数据保证 $s_{1,1}=\texttt +$,$s_{i,1}=s_{1,i}$,$|s_{i,1}|=1$,$s_{i,1}\ne s_{j,1}$ ($i\ne j$)。 保证至多有一组解。 ## 输出格式 第一行输出各个字母表示什么数,格式如:`L=0 K=1` $\cdots$ 按给出的字母顺序排序。不同字母必须代表不同数字。 第二行输出加法运算是几进制的。 若不可能组成加法表,则应输出 `ERROR!`。 ## 样例 #1 ### 样例输入 #1 ``` 5 + L K V E L L K V E K K V E KL V V E KL KK E E KL KK KV ``` ### 样例输出 #1 ``` L=0 K=1 V=2 E=3 4 ``` ## 提示 NOIP1998 提高组 第三题 下面是题目解析和做法:## 题意 给出一个加法表,一个字母代表一个数字。求加法的进制,以及每个大写字母代表的数字。 数字个数 $N\le 8$ 。(行数 $\le 9$) ## 题解 结论: 1. 一定是 $N$ 进制。 2. 每一行有几个二位数,这个数就是几。 --- 证明: 因为有 $N$ 个不同的数,所以最少 $N$ 进制。 假设为 $N+1$ 进制,那么一定有一个数没有出现,假设为 $k$ 。 1. $k=0$ 或 $k=1$,而 $1+N=10$ ,矛盾。 2. $1 &lt; k \le N$ ,而 $1+(k-1)=k$ ,矛盾。 其它 $&gt; N$ 进制的情况同理,所以一定是 $N$ 进制,结论 $1$ 得证。 数字为 $0..N-1$ ,所以结论 $2$ 显然。 --- 有上面的结论后这道题就很好做了。每个数的值都可以预处理出来,记为 $ans[]$ ;同时把字母与数字的对应关系记为 $mp[]$ 。 然后枚举每个数,检验有没有矛盾,如果有就直接输出 `ERROR` 。最后把 $ans[]$ 全部输出即可。 ```cpp #include<bits/stdc++.h> using namespace std; inline int read() { char ch=getchar(); int f=1,x=0; while (ch<'0' || ch>'9') { if (ch=='-') f=-1; ch=getchar(); } while (ch>='0' && ch<='9') { x=x*10+ch-'0'; ch=getchar(); } return f*x; } int n,ans[15],mp[26]; char s[15][15][3]; inline bool check(int x,int y) //检验 (x,y) { int sum=ans[x]+ans[y]; //和 int cur=s[x][y][1]-'A'; //处理十位 if (sum>=n-1 && mp[cur]!=1) return 0; //如果和 >=n-1 但没有进位 if (sum>=n-1) sum-=n-1,cur=s[x][y][2]-'A'; //处理个位 if (mp[cur]!=sum) return 0; //不相等 return 1; } signed main() { n=read(); for (int j=1;j<=n;j++) scanf("%s",s[1][j]+1); for (int i=2;i<=n;i++) { int cnt=0; for (int j=1;j<=n;j++) { scanf("%s",s[i][j]+1); cnt+=strlen(s[i][j]+1)>=2; } ans[i]=cnt; mp[s[i][1][1]-'A']=cnt; } for (int i=2;i<=n;i++) for (int j=2;j<=n;j++) if (!check(i,j)) return 0&puts("ERROR!"); for (int i=2;i<=n;i++) printf("%c=%d ",s[i][1][1],ans[i]); return !printf("\n%d",n-1); } ``` 题目标签:搜索
#include <iostream> #include <map> #define MAXN 10 using namespace std; using i64 [[maybe_unused]] = long long; string arr[MAXN][MAXN]; int ans[MAXN]; map<int, string> m; signed main() { #ifdef LOCAL freopen("test.in", "r", stdin); freopen("test.out", "w", stdout); #endif int n; cin >> n; for (int j = 0; j < n; ++j) { cin >> arr[0][j]; } for (int i = 1; i < n; ++i) { int cnt = 0; for (int j = 0; j < n; ++j) { cin >> arr[i][j]; if (arr[i][j].length() > 1) cnt++; } ans[i] = cnt; m[cnt] = arr[0][i]; } for (int i = 1; i < n; ++i) { for (int j = 1; j < n; ++j) { string s; int p = ans[i] + ans[j]; if (p >= n - 1) { p -= n - 1; s += m[1]; } s += m[p]; if (s != arr[i][j]) { cout << "ERROR!" << endl; return 0; } } } for (int i = 0; i < n - 1; ++i) { cout << m[i] << "=" << i << " "; } cout << endl << n - 1 << endl; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; #define fi first #define se second #define pb push_back #define all(a) a.begin(), a.end() #define rep(i, l, r) for (int i = l; i < r; ++i) #define per(i, r, l) for (int i = r - 1; i >= l; --i) typedef long long ll; typedef pair<int, int> PI; typedef vector<int> VI; typedef vector<ll> VL; typedef vector<PI> VP; template <typename T> bool setmax(T &a, T b) { return (a < b ? a = b : false); } template <typename T> bool setmin(T &a, T b) { return (a > b ? a = b : false); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int n; cin >> n; vector<vector<string>> g(n, vector<string>(n)); unordered_map<char, int> mp; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { cin >> g[i][j]; if (!i) mp[g[i][j][0]] = j; // debug("??", g[i][j][0], j); } } bool ok = false; VI cur(n), ans(n), vis(n); auto dfs = [&](int u, auto &&dfs) -> void { if (ok) return; if (u == n) { auto check = [&]() { for (int i = 1; i < n; i++) { for (int j = 1; j < n; j++) { int val = 1, res = 0; per(k, (int)g[i][j].size(), 0) { res += cur[mp[g[i][j][k]]] * val; val *= (n - 1); } int p = cur[mp[g[0][j][0]]] + cur[mp[g[i][0][0]]]; // debug(g[i][j], p, res, cur[mp[g[0][j][0]]], mp[g[0][j][0]], g[0][j][0]); if (res != p) return false; } } return true; }; if (check()) ok = true; ans = cur; return; } for (int i = 0; i < n; i++) { if (!vis[i]) { cur[u] = i; vis[i] = 1; dfs(u + 1, dfs); vis[i] = 0; cur[u] = 0; } } }; dfs(1, dfs); if (ok) { for (int i = 1; i < n; i++) cout << g[0][i] << "=" << ans[i] << " "; cout << '\n'; cout << n - 1 << '\n'; } else cout << "ERROR!\n"; return 0; }
这里是题目描述:# [NOIP1998 提高组] 进制位 ## 题目描述 著名科学家卢斯为了检查学生对进位制的理解,他给出了如下的一张加法表,表中的字母代表数字。 例如: $$ \def\arraystretch{2} \begin{array}{c||c|c|c|c} \rm + & \kern{.5cm} \rm \mathclap{L} \kern{.5cm} & \kern{.5cm} \rm \mathclap{K} \kern{.5cm} & \kern{.5cm} \rm \mathclap{V} \kern{.5cm} & \kern{.5cm} \rm \mathclap{E} \kern{.5cm} \\ \hline\hline \rm L & \rm L & \rm K & \rm V & \rm E \\ \hline \rm K & \rm K & \rm V & \rm E & \rm \mathclap{KL} \\ \hline \rm V & \rm V & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} \\ \hline \rm E & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} & \rm \mathclap{KV} \\ \end{array}$$ 其含义为: $L+L=L$,$L+K=K$,$L+V=V$,$L+E=E$ $K+L=K$,$K+K=V$,$K+V=E$,$K+E=KL$ $\cdots$ $E+E=KV$ 根据这些规则可推导出:$L=0$,$K=1$,$V=2$,$E=3$。 同时可以确定该表表示的是 $4$ 进制加法。 ## 输入格式 第一行一个整数 $n$($3\le n\le9$)表示行数。 以下 $n$ 行,每行包括 $n$ 个字符串,每个字符串间用空格隔开。) 若记 $s_{i,j}$ 表示第 $i$ 行第 $j$ 个字符串,数据保证 $s_{1,1}=\texttt +$,$s_{i,1}=s_{1,i}$,$|s_{i,1}|=1$,$s_{i,1}\ne s_{j,1}$ ($i\ne j$)。 保证至多有一组解。 ## 输出格式 第一行输出各个字母表示什么数,格式如:`L=0 K=1` $\cdots$ 按给出的字母顺序排序。不同字母必须代表不同数字。 第二行输出加法运算是几进制的。 若不可能组成加法表,则应输出 `ERROR!`。 ## 样例 #1 ### 样例输入 #1 ``` 5 + L K V E L L K V E K K V E KL V V E KL KK E E KL KK KV ``` ### 样例输出 #1 ``` L=0 K=1 V=2 E=3 4 ``` ## 提示 NOIP1998 提高组 第三题 下面是题目解析和做法:## 题意 给出一个加法表,一个字母代表一个数字。求加法的进制,以及每个大写字母代表的数字。 数字个数 $N\le 8$ 。(行数 $\le 9$) ## 题解 结论: 1. 一定是 $N$ 进制。 2. 每一行有几个二位数,这个数就是几。 --- 证明: 因为有 $N$ 个不同的数,所以最少 $N$ 进制。 假设为 $N+1$ 进制,那么一定有一个数没有出现,假设为 $k$ 。 1. $k=0$ 或 $k=1$,而 $1+N=10$ ,矛盾。 2. $1 &lt; k \le N$ ,而 $1+(k-1)=k$ ,矛盾。 其它 $&gt; N$ 进制的情况同理,所以一定是 $N$ 进制,结论 $1$ 得证。 数字为 $0..N-1$ ,所以结论 $2$ 显然。 --- 有上面的结论后这道题就很好做了。每个数的值都可以预处理出来,记为 $ans[]$ ;同时把字母与数字的对应关系记为 $mp[]$ 。 然后枚举每个数,检验有没有矛盾,如果有就直接输出 `ERROR` 。最后把 $ans[]$ 全部输出即可。 ```cpp #include<bits/stdc++.h> using namespace std; inline int read() { char ch=getchar(); int f=1,x=0; while (ch<'0' || ch>'9') { if (ch=='-') f=-1; ch=getchar(); } while (ch>='0' && ch<='9') { x=x*10+ch-'0'; ch=getchar(); } return f*x; } int n,ans[15],mp[26]; char s[15][15][3]; inline bool check(int x,int y) //检验 (x,y) { int sum=ans[x]+ans[y]; //和 int cur=s[x][y][1]-'A'; //处理十位 if (sum>=n-1 && mp[cur]!=1) return 0; //如果和 >=n-1 但没有进位 if (sum>=n-1) sum-=n-1,cur=s[x][y][2]-'A'; //处理个位 if (mp[cur]!=sum) return 0; //不相等 return 1; } signed main() { n=read(); for (int j=1;j<=n;j++) scanf("%s",s[1][j]+1); for (int i=2;i<=n;i++) { int cnt=0; for (int j=1;j<=n;j++) { scanf("%s",s[i][j]+1); cnt+=strlen(s[i][j]+1)>=2; } ans[i]=cnt; mp[s[i][1][1]-'A']=cnt; } for (int i=2;i<=n;i++) for (int j=2;j<=n;j++) if (!check(i,j)) return 0&puts("ERROR!"); for (int i=2;i<=n;i++) printf("%c=%d ",s[i][1][1],ans[i]); return !printf("\n%d",n-1); } ``` 题目标签:搜索
#include <bits/stdc++.h> using namespace std; #define fi first #define se second #define pb push_back #define all(a) a.begin(), a.end() #define rep(i, l, r) for (int i = l; i < r; ++i) #define per(i, r, l) for (int i = r - 1; i >= l; --i) typedef long long ll; typedef pair<int, int> PI; typedef vector<int> VI; typedef vector<ll> VL; typedef vector<PI> VP; template <typename T> bool setmax(T &a, T b) { return (a < b ? a = b : false); } template <typename T> bool setmin(T &a, T b) { return (a > b ? a = b : false); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int n; cin >> n; vector<vector<string>> g(n, vector<string>(n)); unordered_map<char, int> mp; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { cin >> g[i][j]; if (!i) mp[g[i][j][0]] = i; } } bool ok = false; VI cur(n), ans(n), vis(n); auto dfs = [&](int u, auto &&dfs) -> void { if (ok) return; if (u == n) { auto check = [&]() { unordered_map<string, int> v; for (int i = 1; i < n; i++) { for (int j = 1; j < n; j++) { int val = 1, res = 0; per(k, (int)g[i][j].size(), 0) { res += cur[mp[g[i][j][k]]] * val; val *= n; } if (v.count(g[i][j]) && v[g[i][j]] != res) return false; v[g[i][j]] = res; } } return true; }; if (check()) ok = true; ans = cur; return; } for (int i = 0; i < n; i++) { if (!vis[i]) { cur[u] = i; vis[i] = 1; dfs(u + 1, dfs); vis[i] = 0; cur[u] = 0; } } }; dfs(1, dfs); if (ok) { for (int i = 1; i < n; i++) cout << g[0][i] << "=" << ans[i] << " "; cout << '\n'; cout << n - 1 << '\n'; } else cout << "ERROR!\n"; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <random> #include <bits/stdc++.h> #include <unistd.h> using namespace std; #define endl '\n' #define ll long long // ll是64位版本 #define bp __builtin_popcountll #define gcd __gcd typedef std::pair<ll, ll> pii; const ll MOD = 1e9 + 7; // const ll MOD = 998244353; #include <bits/stdc++.h> #define endl '\n' #define ll long long #define ull unsigned long long using namespace std; int n; string s[10][10]; map<string, int> m; void solve() { cin >> n; bool flag = true; for (int i = 1; i <= n; i++) { int cnt = 0; for (int j = 1; j <= n; j++) { cin >> s[i][j]; if (s[i][j].size() > 2) { flag = false; } else if (s[i][j].size() == 2) { cnt++; } } if (i > 1) { m[s[i][1]] = cnt; } } for (int i = 2; i <= n; i++) { for (int j = 2; j <= n; j++) { int target = m[s[i][1]] + m[s[1][j]]; int actual = 0; if (s[i][j].size() == 1) { actual = m[s[i][j]]; } else { actual = m[s[i][j].substr(0, 1)] * (n - 1) + m[s[i][j].substr(1, 1)]; } if (target != actual) { // cout << i << " " << j << " t " << target << " " << actual<< endl; flag = false; } } } if (!flag) { cout << "ERROR!" << endl; return; } for (int i = 2; i <= n; i++) { cout << s[i][1] << "="; cout << m[s[i][1]] << " "; } cout << endl; cout << (n - 1) << endl; } int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int t = 1; // cin >> t; while (t--) { solve(); } return 0; }
这里是题目描述:# [NOIP1998 提高组] 进制位 ## 题目描述 著名科学家卢斯为了检查学生对进位制的理解,他给出了如下的一张加法表,表中的字母代表数字。 例如: $$ \def\arraystretch{2} \begin{array}{c||c|c|c|c} \rm + & \kern{.5cm} \rm \mathclap{L} \kern{.5cm} & \kern{.5cm} \rm \mathclap{K} \kern{.5cm} & \kern{.5cm} \rm \mathclap{V} \kern{.5cm} & \kern{.5cm} \rm \mathclap{E} \kern{.5cm} \\ \hline\hline \rm L & \rm L & \rm K & \rm V & \rm E \\ \hline \rm K & \rm K & \rm V & \rm E & \rm \mathclap{KL} \\ \hline \rm V & \rm V & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} \\ \hline \rm E & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} & \rm \mathclap{KV} \\ \end{array}$$ 其含义为: $L+L=L$,$L+K=K$,$L+V=V$,$L+E=E$ $K+L=K$,$K+K=V$,$K+V=E$,$K+E=KL$ $\cdots$ $E+E=KV$ 根据这些规则可推导出:$L=0$,$K=1$,$V=2$,$E=3$。 同时可以确定该表表示的是 $4$ 进制加法。 ## 输入格式 第一行一个整数 $n$($3\le n\le9$)表示行数。 以下 $n$ 行,每行包括 $n$ 个字符串,每个字符串间用空格隔开。) 若记 $s_{i,j}$ 表示第 $i$ 行第 $j$ 个字符串,数据保证 $s_{1,1}=\texttt +$,$s_{i,1}=s_{1,i}$,$|s_{i,1}|=1$,$s_{i,1}\ne s_{j,1}$ ($i\ne j$)。 保证至多有一组解。 ## 输出格式 第一行输出各个字母表示什么数,格式如:`L=0 K=1` $\cdots$ 按给出的字母顺序排序。不同字母必须代表不同数字。 第二行输出加法运算是几进制的。 若不可能组成加法表,则应输出 `ERROR!`。 ## 样例 #1 ### 样例输入 #1 ``` 5 + L K V E L L K V E K K V E KL V V E KL KK E E KL KK KV ``` ### 样例输出 #1 ``` L=0 K=1 V=2 E=3 4 ``` ## 提示 NOIP1998 提高组 第三题 下面是题目解析和做法:## 题意 给出一个加法表,一个字母代表一个数字。求加法的进制,以及每个大写字母代表的数字。 数字个数 $N\le 8$ 。(行数 $\le 9$) ## 题解 结论: 1. 一定是 $N$ 进制。 2. 每一行有几个二位数,这个数就是几。 --- 证明: 因为有 $N$ 个不同的数,所以最少 $N$ 进制。 假设为 $N+1$ 进制,那么一定有一个数没有出现,假设为 $k$ 。 1. $k=0$ 或 $k=1$,而 $1+N=10$ ,矛盾。 2. $1 &lt; k \le N$ ,而 $1+(k-1)=k$ ,矛盾。 其它 $&gt; N$ 进制的情况同理,所以一定是 $N$ 进制,结论 $1$ 得证。 数字为 $0..N-1$ ,所以结论 $2$ 显然。 --- 有上面的结论后这道题就很好做了。每个数的值都可以预处理出来,记为 $ans[]$ ;同时把字母与数字的对应关系记为 $mp[]$ 。 然后枚举每个数,检验有没有矛盾,如果有就直接输出 `ERROR` 。最后把 $ans[]$ 全部输出即可。 ```cpp #include<bits/stdc++.h> using namespace std; inline int read() { char ch=getchar(); int f=1,x=0; while (ch<'0' || ch>'9') { if (ch=='-') f=-1; ch=getchar(); } while (ch>='0' && ch<='9') { x=x*10+ch-'0'; ch=getchar(); } return f*x; } int n,ans[15],mp[26]; char s[15][15][3]; inline bool check(int x,int y) //检验 (x,y) { int sum=ans[x]+ans[y]; //和 int cur=s[x][y][1]-'A'; //处理十位 if (sum>=n-1 && mp[cur]!=1) return 0; //如果和 >=n-1 但没有进位 if (sum>=n-1) sum-=n-1,cur=s[x][y][2]-'A'; //处理个位 if (mp[cur]!=sum) return 0; //不相等 return 1; } signed main() { n=read(); for (int j=1;j<=n;j++) scanf("%s",s[1][j]+1); for (int i=2;i<=n;i++) { int cnt=0; for (int j=1;j<=n;j++) { scanf("%s",s[i][j]+1); cnt+=strlen(s[i][j]+1)>=2; } ans[i]=cnt; mp[s[i][1][1]-'A']=cnt; } for (int i=2;i<=n;i++) for (int j=2;j<=n;j++) if (!check(i,j)) return 0&puts("ERROR!"); for (int i=2;i<=n;i++) printf("%c=%d ",s[i][1][1],ans[i]); return !printf("\n%d",n-1); } ``` 题目标签:搜索
#include <random> #include <bits/stdc++.h> #include <unistd.h> using namespace std; #define endl '\n' #define ll long long // ll是64位版本 #define bp __builtin_popcountll #define gcd __gcd typedef std::pair<ll, ll> pii; const ll MOD = 1e9 + 7; // const ll MOD = 998244353; #include <bits/stdc++.h> #define endl '\n' #define ll long long #define ull unsigned long long using namespace std; int n; string s[10][10]; bool vis[10]; void solve() { cin >> n; bool flag = true; for (int i = 1; i <= n; i++) { int cnt = 0; for (int j = 1; j <= n; j++) { cin >> s[i][j]; if (s[i][j].size() > 2) { flag = false; } else if (s[i][j].size() == 2) { cnt++; } } if (i > 1) { if (vis[cnt]) { flag = false; } else { vis[cnt] = true; } } } if (!flag) { cout << "ERROR!" << endl; return; } for (int i = 2; i <= n; i++) { cout << s[i][1] << "="; int cnt = 0; for (int j = 2; j <= n; j++) { if (s[i][j].size() == 2) { cnt++; } } cout << cnt << " "; } cout << endl; cout << (n - 1) << endl; } int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int t = 1; // cin >> t; while (t--) { solve(); } return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <cstdio> using namespace std; /* int search(int n){ bool success = false; return 0; }*/ int find(char x, char know[]) { for (int j = 0; j < 15; j++) { if (x == know[j]) { return j; } } return -1; } char get[15][15][5]; int main() { int n; // char ipt[50]; scanf("%d", &n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { scanf("%s", get[i][j]); } } /*for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ printf("%s ",get[i][j]); } printf("\n"); }*/ // search(n); // find 0 char know[15] = {0}; for (int i = 1; i < n; i++) { if (get[1][i][0] == get[1][0][0] && get[1][i][1] == get[1][0][1]) { know[0] = get[0][i][0]; break; } } // find 10 bool success = false; for (int i = 1; i < n; i++) { for (int j = n - 1; j >= 0; j--) { if (get[i][j][1] == know[0]) { know[1] = get[i][j][0]; success = true; } } if (success) { break; } } int idx1; // find 1_x for (int i = 0; i < n; i++) { if (get[i][0][0] == know[1]) { idx1 = i; break; } } char now = know[1]; // generate to n for (int i = 2; i < n; i++) { for (int j = 0; j < n; j++) { if (get[0][j][0] == now) { now = get[idx1][j][0]; know[i] = now; break; } } } // check success = true; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - 1; j++) { int sum = 0; if (get[i + 1][j + 1][1] == '\0') { sum += find(get[i + 1][j + 1][0], know); } else { sum += n; sum += find(get[i + 1][j + 1][1], know); } if (find(get[0][j + 1][0], know) + find(get[0][i + 1][0], know) != sum && find(get[0][j + 1][0], know) + find(get[0][i + 1][0], know) != sum - 1) { success = false; // printf("%d=%d+%d\n",sum-1,find(get[0][j+1][0],know),find(get[0][i+1][0],know)); } } } if (!success) { printf("ERROR!"); return 0; } for (int i = 1; i < n; i++) { for (int j = 0; j < n - 1; j++) { if (get[0][i][0] == know[j]) { printf("%c=%d ", know[j], j); break; } } } printf("\n%d", n - 1); return 0; }
这里是题目描述:# [NOIP1998 提高组] 进制位 ## 题目描述 著名科学家卢斯为了检查学生对进位制的理解,他给出了如下的一张加法表,表中的字母代表数字。 例如: $$ \def\arraystretch{2} \begin{array}{c||c|c|c|c} \rm + & \kern{.5cm} \rm \mathclap{L} \kern{.5cm} & \kern{.5cm} \rm \mathclap{K} \kern{.5cm} & \kern{.5cm} \rm \mathclap{V} \kern{.5cm} & \kern{.5cm} \rm \mathclap{E} \kern{.5cm} \\ \hline\hline \rm L & \rm L & \rm K & \rm V & \rm E \\ \hline \rm K & \rm K & \rm V & \rm E & \rm \mathclap{KL} \\ \hline \rm V & \rm V & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} \\ \hline \rm E & \rm E & \rm \mathclap{KL} & \rm \mathclap{KK} & \rm \mathclap{KV} \\ \end{array}$$ 其含义为: $L+L=L$,$L+K=K$,$L+V=V$,$L+E=E$ $K+L=K$,$K+K=V$,$K+V=E$,$K+E=KL$ $\cdots$ $E+E=KV$ 根据这些规则可推导出:$L=0$,$K=1$,$V=2$,$E=3$。 同时可以确定该表表示的是 $4$ 进制加法。 ## 输入格式 第一行一个整数 $n$($3\le n\le9$)表示行数。 以下 $n$ 行,每行包括 $n$ 个字符串,每个字符串间用空格隔开。) 若记 $s_{i,j}$ 表示第 $i$ 行第 $j$ 个字符串,数据保证 $s_{1,1}=\texttt +$,$s_{i,1}=s_{1,i}$,$|s_{i,1}|=1$,$s_{i,1}\ne s_{j,1}$ ($i\ne j$)。 保证至多有一组解。 ## 输出格式 第一行输出各个字母表示什么数,格式如:`L=0 K=1` $\cdots$ 按给出的字母顺序排序。不同字母必须代表不同数字。 第二行输出加法运算是几进制的。 若不可能组成加法表,则应输出 `ERROR!`。 ## 样例 #1 ### 样例输入 #1 ``` 5 + L K V E L L K V E K K V E KL V V E KL KK E E KL KK KV ``` ### 样例输出 #1 ``` L=0 K=1 V=2 E=3 4 ``` ## 提示 NOIP1998 提高组 第三题 下面是题目解析和做法:## 题意 给出一个加法表,一个字母代表一个数字。求加法的进制,以及每个大写字母代表的数字。 数字个数 $N\le 8$ 。(行数 $\le 9$) ## 题解 结论: 1. 一定是 $N$ 进制。 2. 每一行有几个二位数,这个数就是几。 --- 证明: 因为有 $N$ 个不同的数,所以最少 $N$ 进制。 假设为 $N+1$ 进制,那么一定有一个数没有出现,假设为 $k$ 。 1. $k=0$ 或 $k=1$,而 $1+N=10$ ,矛盾。 2. $1 &lt; k \le N$ ,而 $1+(k-1)=k$ ,矛盾。 其它 $&gt; N$ 进制的情况同理,所以一定是 $N$ 进制,结论 $1$ 得证。 数字为 $0..N-1$ ,所以结论 $2$ 显然。 --- 有上面的结论后这道题就很好做了。每个数的值都可以预处理出来,记为 $ans[]$ ;同时把字母与数字的对应关系记为 $mp[]$ 。 然后枚举每个数,检验有没有矛盾,如果有就直接输出 `ERROR` 。最后把 $ans[]$ 全部输出即可。 ```cpp #include<bits/stdc++.h> using namespace std; inline int read() { char ch=getchar(); int f=1,x=0; while (ch<'0' || ch>'9') { if (ch=='-') f=-1; ch=getchar(); } while (ch>='0' && ch<='9') { x=x*10+ch-'0'; ch=getchar(); } return f*x; } int n,ans[15],mp[26]; char s[15][15][3]; inline bool check(int x,int y) //检验 (x,y) { int sum=ans[x]+ans[y]; //和 int cur=s[x][y][1]-'A'; //处理十位 if (sum>=n-1 && mp[cur]!=1) return 0; //如果和 >=n-1 但没有进位 if (sum>=n-1) sum-=n-1,cur=s[x][y][2]-'A'; //处理个位 if (mp[cur]!=sum) return 0; //不相等 return 1; } signed main() { n=read(); for (int j=1;j<=n;j++) scanf("%s",s[1][j]+1); for (int i=2;i<=n;i++) { int cnt=0; for (int j=1;j<=n;j++) { scanf("%s",s[i][j]+1); cnt+=strlen(s[i][j]+1)>=2; } ans[i]=cnt; mp[s[i][1][1]-'A']=cnt; } for (int i=2;i<=n;i++) for (int j=2;j<=n;j++) if (!check(i,j)) return 0&puts("ERROR!"); for (int i=2;i<=n;i++) printf("%c=%d ",s[i][1][1],ans[i]); return !printf("\n%d",n-1); } ``` 题目标签:搜索
#include <cstdio> using namespace std; /* int search(int n){ bool success = false; return 0; }*/ char get[15][15][5]; int main() { int n; // char ipt[50]; scanf("%d", &n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { scanf("%s", get[i][j]); } } /*for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ printf("%s ",get[i][j]); } printf("\n"); }*/ // search(n); // find 0 char know[15] = {0}; for (int i = 1; i < n; i++) { if (get[1][i][0] == get[1][0][0] && get[1][i][1] == get[1][0][1]) { know[0] = get[0][i][0]; break; } } // find 10 bool success = false; for (int i = 1; i < n; i++) { for (int j = n - 1; j >= 0; j--) { if (get[i][j][1] == know[0]) { know[1] = get[i][j][0]; success = true; } } if (success) { break; } } int idx1; // find 1_x for (int i = 0; i < n; i++) { if (get[i][0][0] == know[1]) { idx1 = i; break; } } char now = know[1]; // generate to n for (int i = 2; i < n; i++) { for (int j = 0; j < n; j++) { if (get[0][j][0] == now) { now = get[idx1][j][0]; know[i] = now; break; } } } for (int i = 0; i < n - 1; i++) { printf("%c=%d ", know[i], i); } printf("\n%d", n - 1); return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> #include <map> #include <queue> #include <set> #include <vector> #define int long long #define ull unsigned long long #define endl '\n' #define all(s) s.begin(), s.end() #define xx first #define yy second #define inf 0x3f3f3f3f3f3f3f3f #define N 1000005 #define mod 1000000007 // 998244353 #define double long double #define lowbit(x) ((x) & (-x)) #define ls(x) (x << 1) #define rs(x) ((x << 1) | 1) #define pll pair<int, int> #define __lcm(a, b) (a / __gcd(a, b) * b) const double pi = acos(-1); const int P = 233333; const int PP = 1313131; const int mod1 = 1000001011; const int mod2 = (1ll << 31) - 1; using namespace std; int arr[15][15]; int dp[15][15]; void show(int n) { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { printf("%2lld ", dp[i][j]); } cout << endl; } cout << endl; } void move(int n) { map<int, pll> ma; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (!ma.count(dp[i][j])) ma[dp[i][j]] = {i, j}; } } int x = n, y = n; while (dp[x][y]) { pll now = ma[dp[x][y]]; x = now.xx, y = now.yy; arr[x][y] = 0; if (dp[x - 1][y] > dp[x][y - 1]) x--; else y--; } } void solve() { int n; cin >> n; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) arr[i][j] = 0; } for (int a, b, c; cin >> a >> b >> c && a && b && c;) arr[a][b] = c; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { dp[i][j] = 0; dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]) + arr[i][j]; } } int ans = dp[n][n]; // show(n); move(n); for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { dp[i][j] = 0; dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]) + arr[i][j]; } } // show(n); cout << dp[n][n] + ans << endl; } signed main() { ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); int T = 1; // cin>>T; while (T--) { solve(); } return 0; }
这里是题目描述:# [NOIP2000 提高组] 方格取数 ## 题目背景 NOIP 2000 提高组 T4 ## 题目描述 设有 $N \times N$ 的方格图 $(N \le 9)$,我们将其中的某些方格中填入正整数,而其他的方格中则放入数字 $0$。如下图所示(见样例): ![](https://cdn.luogu.com.cn/upload/image_hosting/0bpummja.png) 某人从图的左上角的 $A$ 点出发,可以向下行走,也可以向右走,直到到达右下角的 $B$ 点。在走过的路上,他可以取走方格中的数(取走后的方格中将变为数字 $0$)。 此人从 $A$ 点到 $B$ 点共走两次,试找出 $2$ 条这样的路径,使得取得的数之和为最大。 ## 输入格式 输入的第一行为一个整数 $N$(表示 $N \times N$ 的方格图),接下来的每行有三个整数,前两个表示位置,第三个数为该位置上所放的数。一行单独的 $0$ 表示输入结束。 ## 输出格式 只需输出一个整数,表示 $2$ 条路径上取得的最大的和。 ## 样例 #1 ### 样例输入 #1 ``` 8 2 3 13 2 6 6 3 5 7 4 4 14 5 2 21 5 6 4 6 3 15 7 2 14 0 0 0 ``` ### 样例输出 #1 ``` 67 ``` ## 提示 数据范围:$1\le N\le 9$。 下面是题目解析和做法:第一份题解: ###深搜深搜 见都是动规的帖子,来来来,贴一个深搜的题解(手动滑稽)。。。 这道题深搜的最优方法就是两种方案同时从起点出发。因为如果记录完第一种方案,再计算第二种方案,不可控的因素太多了,大多都不是最优解→\_→,但两种方案同时执行就行,因为这可以根据当前的情况来判断最优。 总的来说,每走一步都会有四个分支(你理解成选择或者情况也可以): 1、两种都向下走 2、第一种向下走,第二种向右走 3、第一种向右走,第二种向下走 4、两种都向右走 每走一步走枚举一下这四种情况,因为在每个点的方案具有唯一性(也就是在某个点走到终点的取数方案只有一个最优解,自己理解一下),所以我们可以开一个数组来记录每一种情况,当重复枚举到一种情况时就直接返回(对,就是剪枝),大大节省了时间(不然会超时哦~)。深搜和动归的时间复杂度时一样的! 附代码: ```cpp //方格取数~深搜 ~( ̄▽ ̄~)(~ ̄▽ ̄)~ #include &lt;iostream &gt;using namespace std; int N=0; int s[15][15],f[11][11][11][11]; int dfs(int x,int y,int x2,int y2)//两种方案同时执行,表示当第一种方案走到x,y,第二种方案走到x2,y2时到终点取得的最大数 { if (f[x][y][x2][y2]!=-1) return f[x][y][x2][y2];//如果这种情况已经被记录过了,直接返回,节省时间 if (x==N &amp;&amp;y==N &amp;&amp;x2==N &amp;&amp;y2==N) return 0;//如果两种方案都走到了终点,返回结束 int M=0; //如果两种方案都不在最后一列,就都往下走,统计取得的数,如果有重复,就减去一部分 if (x &lt;N &amp;&amp;x2 &lt;N) M=max(M,dfs(x+1,y,x2+1,y2)+s[x+1][y]+s[x2+1][y2]-s[x+1][y]*(x+1==x2+1 &amp;&amp;y==y2)); //如果第一种方案不在最后一行,第二种方案不在最后一列,第一种就向下走,第二种就向右走, //统计取得的数,如果有重复,就减去一部分 if (x &lt;N &amp;&amp;y2 &lt;N) M=max(M,dfs(x+1,y,x2,y2+1)+s[x+1][y]+s[x2][y2+1]-s[x+1][y]*(x+1==x2 &amp;&amp;y==y2+1)); //如果第一种方案不在最后一列,第二种方案不在最后一行,第一种就向右走,第二种就向下走, //统计取得的数,如果有重复,就减去一部分 if (y &lt;N &amp;&amp;x2 &lt;N) M=max(M,dfs(x,y+1,x2+1,y2)+s[x][y+1]+s[x2+1][y2]-s[x][y+1]*(x==x2+1 &amp;&amp;y+1==y2)); //如果第一种方案和第二种方案都不在最后一列,就都向右走,统计取得的数,如果有重复,就减去一部分 if (y &lt;N &amp;&amp;y2 &lt;N) M=max(M,dfs(x,y+1,x2,y2+1)+s[x][y+1]+s[x2][y2+1]-s[x][y+1]*(x==x2 &amp;&amp;y+1==y2+1)); //对最后那个 s[x][y+1]*(x==x2 &amp;&amp;y+1==y2+1))的解释:这个是用来判断两种方案是不是走到了同一格的 //如果是真,就返回1,否则返回0,如果是1的话,理所当然的可以减去s[x][y+1]*1,否则减去s[x][y+1]*0相当于 //不减,写得有点精简,省了4个if,见谅哈~ f[x][y][x2][y2]=M;//记录这种情况 return M;//返回最大值 } int main() { cin &gt;&gt;N; //将记录数组初始化成-1,因为可能出现取的数为0的情况,如果直接判断f[x][y][x2][y2]!=0(见dfs第一行) //可能出现死循环而导致超时,细节问题 for(int a=0;a &lt;=N;a++) for(int b=0;b &lt;=N;b++) for(int c=0;c &lt;=N;c++) for(int d=0;d &lt;=N;d++) f[a][b][c][d]=-1; for(;;)//读入 { int t1=0,t2=0,t3=0; cin &gt;&gt;t1 &gt;&gt;t2 &gt;&gt;t3; if(t1==0 &amp;&amp;t2==0 &amp;&amp;t3==0) break; s[t1][t2]=t3; } cout &lt;&lt;dfs(1,1,1,1)+s[1][1];//输出,因为dfs中没有考虑第一格,即s[1][1],所以最后要加一下 return 0; } ``` 第二份题解: 一道典型的棋盘dp。 一共需要走两次,我们不妨同时处理这两条路径。这样,我们既可以方便地处理两条路径重合的情况,也可以减少代码的时间复杂度。 最朴素的想法是开一个四维数组$f[x_1][y_1][x_2][y_2]$表示当两条路径分别处理到$(x_1,y_1)$和$(x_2,y_2)$时能够获得的最大的累积和。但是,四维数组处理起来时间复杂度太大了,所以我们要想办法把它降成三维。 我们可以发现,每当我们走一步,那么x坐标和y坐标之间总会有一个数加$1$。所以,我们可以用k来表示x坐标和y坐标的和,从而通过y坐标来计算出x坐标。由于k对于两条同时处理的路径可以是公共的,所以我们可以用$f[k][y_1][y_2]$来表示当前状态。 特殊的,由于每一个方格的数只可以取一次,所以我们要判断i和j是否相当。 于是,我们就可以得到一个状态转移方程了: $$f[k][i][j]=max(f[k-1][i][j],f[k-1][i-1][j]f[k-1][i][j-1]f[k-1][i-1][j-1])+[(i==j)?map[k-i+1][i]:map[k-i+1][i] + map[k-j+1][j]]$$ 我们可以来看一下我们到底是通过哪些状态转移到当前状态的: ![](https://cdn.luogu.com.cn/upload/pic/71682.png) code: ```cpp #include &lt;iostream &gt;#include &lt;cstring &gt;#include &lt;cstdio &gt;#include &lt;cmath &gt;#include &lt;algorithm &gt;#define ll long long #define INF 0x7fffffff #define re register #define qwq printf(&quot;qwq\n &quot;); using namespace std; int read() { register int x = 0,f = 1;register char ch; ch = getchar(); while(ch &gt;&#039;9 &#039;|| ch &lt;&#039;0 &#039;){if(ch == &#039;-&#039;) f = -f;ch = getchar();} while(ch &lt;= &#039;9 &#039;&amp;&amp;ch &gt;= &#039;0 &#039;){x = x * 10 + ch - 48;ch = getchar();} return x * f; } int n,m,map[205][205],f[205][205][205],x,y,v; int cmp(int a,int b,int c,int d) { a = max(a,b); c = max(c,d); return max(a,c); } int main() { m = read(); n = m; x = read(); y = read(); v = read(); while(x &gt;0) { map[x][y] = v; x = read(); y = read(); v = read(); } for(int k = 1; k &lt;= m + n; k++) for(int i = 1; i &lt;= min(k,n); i++) for(int j = 1; j &lt;= min(k,n); j++) { f[k][i][j] = cmp(f[k - 1][i][j],f[k - 1][i - 1][j],f[k - 1][i][j - 1],f[k - 1][i - 1][j - 1]) + map[k - i + 1][i] + map[k - j + 1][j]; if(i == j) f[k][i][j] -= map[k - i + 1][i]; } f[n + m][n][n] = cmp(f[n + m - 1][n][n - 1],f[n + m - 1][n - 1][n],f[n + m - 1][n][n],f[n + m - 1][n - 1][n - 1]); printf(&quot;%d\n &quot;,f[n + m][n][n]); return 0; } ``` 题目标签:动 态 规 划
#include <bits/stdc++.h> #include <map> #include <queue> #include <set> #include <vector> #define int long long #define ull unsigned long long #define endl '\n' #define all(s) s.begin(), s.end() #define xx first #define yy second #define inf 0x3f3f3f3f3f3f3f3f #define N 1000005 #define mod 1000000007 // 998244353 #define double long double #define lowbit(x) ((x) & (-x)) #define ls(x) (x << 1) #define rs(x) ((x << 1) | 1) #define pll pair<int, int> #define __lcm(a, b) (a / __gcd(a, b) * b) const double pi = acos(-1); const int P = 233333; const int PP = 1313131; const int mod1 = 1000001011; const int mod2 = (1ll << 31) - 1; using namespace std; int arr[15][15]; int dp[15][15]; void show(int n) { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { printf("%2lld ", dp[i][j]); } cout << endl; } cout << endl; } void move(int n) { map<int, pll> ma; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (!ma.count(dp[i][j])) ma[dp[i][j]] = {i, j}; } } int x = n, y = n; while (dp[x][y]) { pll now = ma[dp[x][y]]; x = now.xx, y = now.yy; arr[x][y] = 0; x--, y--; } } void solve() { int n; cin >> n; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) arr[i][j] = 0; } for (int a, b, c; cin >> a >> b >> c && a && b && c;) arr[a][b] = c; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { dp[i][j] = 0; dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]) + arr[i][j]; } } int ans = dp[n][n]; // show(n); move(n); for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { dp[i][j] = 0; dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]) + arr[i][j]; } } cout << dp[n][n] + ans << endl; } signed main() { ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); int T = 1; // cin>>T; while (T--) { solve(); } return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> int main() { int n; std::cin >> n; std::vector a(n + 5, std::vector<int>(n + 5, 0)); int i = 1, j, num; while (i) { std::cin >> i >> j >> num; a[i][j] = num; } std::vector dp(2 * n + 5, std::vector(n + 5, std::vector<int>(n + 5, 0))); dp[0][1][1] = a[1][1]; for (int k = 1; k <= 2 * n - 2; k++) { for (int i = 1; i <= n && i <= k + 1; i++) { for (int j = 1; j <= n && j <= k + 1; j++) { if (k - i + 2 > n && k - j + 2 > n) break; int d = a[i][k - i + 2] + a[j][k - j + 2]; if (i == j) d /= 2; // if (a[i][k - i + 2]) std::cerr << i << ' ' << k - i + 2 << ' ' << a[i][k - i + 2] << '\n'; // if (a[j][k - j + 2]) std::cerr << j << ' ' << k - j + 2 << ' ' << a[j][k - j + 2] << '\n'; dp[k][i][j] = std::max(dp[k][i][j], dp[k - 1][i - 1][j - 1] + d); dp[k][i][j] = std::max(dp[k][i][j], dp[k - 1][i][j - 1] + d); dp[k][i][j] = std::max(dp[k][i][j], dp[k - 1][i - 1][j] + d); dp[k][i][j] = std::max(dp[k][i][j], dp[k - 1][i][j] + d); } } } std::cout << dp[2 * n - 2][n][n]; }
这里是题目描述:# [NOIP2000 提高组] 方格取数 ## 题目背景 NOIP 2000 提高组 T4 ## 题目描述 设有 $N \times N$ 的方格图 $(N \le 9)$,我们将其中的某些方格中填入正整数,而其他的方格中则放入数字 $0$。如下图所示(见样例): ![](https://cdn.luogu.com.cn/upload/image_hosting/0bpummja.png) 某人从图的左上角的 $A$ 点出发,可以向下行走,也可以向右走,直到到达右下角的 $B$ 点。在走过的路上,他可以取走方格中的数(取走后的方格中将变为数字 $0$)。 此人从 $A$ 点到 $B$ 点共走两次,试找出 $2$ 条这样的路径,使得取得的数之和为最大。 ## 输入格式 输入的第一行为一个整数 $N$(表示 $N \times N$ 的方格图),接下来的每行有三个整数,前两个表示位置,第三个数为该位置上所放的数。一行单独的 $0$ 表示输入结束。 ## 输出格式 只需输出一个整数,表示 $2$ 条路径上取得的最大的和。 ## 样例 #1 ### 样例输入 #1 ``` 8 2 3 13 2 6 6 3 5 7 4 4 14 5 2 21 5 6 4 6 3 15 7 2 14 0 0 0 ``` ### 样例输出 #1 ``` 67 ``` ## 提示 数据范围:$1\le N\le 9$。 下面是题目解析和做法:第一份题解: ###深搜深搜 见都是动规的帖子,来来来,贴一个深搜的题解(手动滑稽)。。。 这道题深搜的最优方法就是两种方案同时从起点出发。因为如果记录完第一种方案,再计算第二种方案,不可控的因素太多了,大多都不是最优解→\_→,但两种方案同时执行就行,因为这可以根据当前的情况来判断最优。 总的来说,每走一步都会有四个分支(你理解成选择或者情况也可以): 1、两种都向下走 2、第一种向下走,第二种向右走 3、第一种向右走,第二种向下走 4、两种都向右走 每走一步走枚举一下这四种情况,因为在每个点的方案具有唯一性(也就是在某个点走到终点的取数方案只有一个最优解,自己理解一下),所以我们可以开一个数组来记录每一种情况,当重复枚举到一种情况时就直接返回(对,就是剪枝),大大节省了时间(不然会超时哦~)。深搜和动归的时间复杂度时一样的! 附代码: ```cpp //方格取数~深搜 ~( ̄▽ ̄~)(~ ̄▽ ̄)~ #include &lt;iostream &gt;using namespace std; int N=0; int s[15][15],f[11][11][11][11]; int dfs(int x,int y,int x2,int y2)//两种方案同时执行,表示当第一种方案走到x,y,第二种方案走到x2,y2时到终点取得的最大数 { if (f[x][y][x2][y2]!=-1) return f[x][y][x2][y2];//如果这种情况已经被记录过了,直接返回,节省时间 if (x==N &amp;&amp;y==N &amp;&amp;x2==N &amp;&amp;y2==N) return 0;//如果两种方案都走到了终点,返回结束 int M=0; //如果两种方案都不在最后一列,就都往下走,统计取得的数,如果有重复,就减去一部分 if (x &lt;N &amp;&amp;x2 &lt;N) M=max(M,dfs(x+1,y,x2+1,y2)+s[x+1][y]+s[x2+1][y2]-s[x+1][y]*(x+1==x2+1 &amp;&amp;y==y2)); //如果第一种方案不在最后一行,第二种方案不在最后一列,第一种就向下走,第二种就向右走, //统计取得的数,如果有重复,就减去一部分 if (x &lt;N &amp;&amp;y2 &lt;N) M=max(M,dfs(x+1,y,x2,y2+1)+s[x+1][y]+s[x2][y2+1]-s[x+1][y]*(x+1==x2 &amp;&amp;y==y2+1)); //如果第一种方案不在最后一列,第二种方案不在最后一行,第一种就向右走,第二种就向下走, //统计取得的数,如果有重复,就减去一部分 if (y &lt;N &amp;&amp;x2 &lt;N) M=max(M,dfs(x,y+1,x2+1,y2)+s[x][y+1]+s[x2+1][y2]-s[x][y+1]*(x==x2+1 &amp;&amp;y+1==y2)); //如果第一种方案和第二种方案都不在最后一列,就都向右走,统计取得的数,如果有重复,就减去一部分 if (y &lt;N &amp;&amp;y2 &lt;N) M=max(M,dfs(x,y+1,x2,y2+1)+s[x][y+1]+s[x2][y2+1]-s[x][y+1]*(x==x2 &amp;&amp;y+1==y2+1)); //对最后那个 s[x][y+1]*(x==x2 &amp;&amp;y+1==y2+1))的解释:这个是用来判断两种方案是不是走到了同一格的 //如果是真,就返回1,否则返回0,如果是1的话,理所当然的可以减去s[x][y+1]*1,否则减去s[x][y+1]*0相当于 //不减,写得有点精简,省了4个if,见谅哈~ f[x][y][x2][y2]=M;//记录这种情况 return M;//返回最大值 } int main() { cin &gt;&gt;N; //将记录数组初始化成-1,因为可能出现取的数为0的情况,如果直接判断f[x][y][x2][y2]!=0(见dfs第一行) //可能出现死循环而导致超时,细节问题 for(int a=0;a &lt;=N;a++) for(int b=0;b &lt;=N;b++) for(int c=0;c &lt;=N;c++) for(int d=0;d &lt;=N;d++) f[a][b][c][d]=-1; for(;;)//读入 { int t1=0,t2=0,t3=0; cin &gt;&gt;t1 &gt;&gt;t2 &gt;&gt;t3; if(t1==0 &amp;&amp;t2==0 &amp;&amp;t3==0) break; s[t1][t2]=t3; } cout &lt;&lt;dfs(1,1,1,1)+s[1][1];//输出,因为dfs中没有考虑第一格,即s[1][1],所以最后要加一下 return 0; } ``` 第二份题解: 一道典型的棋盘dp。 一共需要走两次,我们不妨同时处理这两条路径。这样,我们既可以方便地处理两条路径重合的情况,也可以减少代码的时间复杂度。 最朴素的想法是开一个四维数组$f[x_1][y_1][x_2][y_2]$表示当两条路径分别处理到$(x_1,y_1)$和$(x_2,y_2)$时能够获得的最大的累积和。但是,四维数组处理起来时间复杂度太大了,所以我们要想办法把它降成三维。 我们可以发现,每当我们走一步,那么x坐标和y坐标之间总会有一个数加$1$。所以,我们可以用k来表示x坐标和y坐标的和,从而通过y坐标来计算出x坐标。由于k对于两条同时处理的路径可以是公共的,所以我们可以用$f[k][y_1][y_2]$来表示当前状态。 特殊的,由于每一个方格的数只可以取一次,所以我们要判断i和j是否相当。 于是,我们就可以得到一个状态转移方程了: $$f[k][i][j]=max(f[k-1][i][j],f[k-1][i-1][j]f[k-1][i][j-1]f[k-1][i-1][j-1])+[(i==j)?map[k-i+1][i]:map[k-i+1][i] + map[k-j+1][j]]$$ 我们可以来看一下我们到底是通过哪些状态转移到当前状态的: ![](https://cdn.luogu.com.cn/upload/pic/71682.png) code: ```cpp #include &lt;iostream &gt;#include &lt;cstring &gt;#include &lt;cstdio &gt;#include &lt;cmath &gt;#include &lt;algorithm &gt;#define ll long long #define INF 0x7fffffff #define re register #define qwq printf(&quot;qwq\n &quot;); using namespace std; int read() { register int x = 0,f = 1;register char ch; ch = getchar(); while(ch &gt;&#039;9 &#039;|| ch &lt;&#039;0 &#039;){if(ch == &#039;-&#039;) f = -f;ch = getchar();} while(ch &lt;= &#039;9 &#039;&amp;&amp;ch &gt;= &#039;0 &#039;){x = x * 10 + ch - 48;ch = getchar();} return x * f; } int n,m,map[205][205],f[205][205][205],x,y,v; int cmp(int a,int b,int c,int d) { a = max(a,b); c = max(c,d); return max(a,c); } int main() { m = read(); n = m; x = read(); y = read(); v = read(); while(x &gt;0) { map[x][y] = v; x = read(); y = read(); v = read(); } for(int k = 1; k &lt;= m + n; k++) for(int i = 1; i &lt;= min(k,n); i++) for(int j = 1; j &lt;= min(k,n); j++) { f[k][i][j] = cmp(f[k - 1][i][j],f[k - 1][i - 1][j],f[k - 1][i][j - 1],f[k - 1][i - 1][j - 1]) + map[k - i + 1][i] + map[k - j + 1][j]; if(i == j) f[k][i][j] -= map[k - i + 1][i]; } f[n + m][n][n] = cmp(f[n + m - 1][n][n - 1],f[n + m - 1][n - 1][n],f[n + m - 1][n][n],f[n + m - 1][n - 1][n - 1]); printf(&quot;%d\n &quot;,f[n + m][n][n]); return 0; } ``` 题目标签:动 态 规 划
#include <bits/stdc++.h> int main() { int n; std::cin >> n; std::vector a(n + 5, std::vector<int>(n + 5, 0)); int i = 1, j, num; while (i) { std::cin >> i >> j >> num; a[i][j] = num; } std::vector dp(2 * n + 5, std::vector(n + 5, std::vector<int>(n + 5, 0))); dp[0][1][1] = a[1][1]; for (int k = 1; k <= 2 * n - 2; k++) { for (int i = 1; i <= n && i <= k; i++) { for (int j = 1; j <= n && j <= k; j++) { if (k - i + 2 > n && k - j + 2 > n) break; int d = a[i][k - i + 2] + a[j][k - j + 2]; if (i == j) d /= 2; // if (a[i][k - i + 2]) std::cerr << i << ' ' << k - i + 2 << ' ' << a[i][k - i + 2] << '\n'; dp[k][i][j] = std::max(dp[k][i][j], dp[k - 1][i - 1][j - 1] + d); dp[k][i][j] = std::max(dp[k][i][j], dp[k - 1][i][j - 1] + d); dp[k][i][j] = std::max(dp[k][i][j], dp[k - 1][i - 1][j] + d); dp[k][i][j] = std::max(dp[k][i][j], dp[k - 1][i][j] + d); } } } std::cout << dp[2 * n - 2][n][n]; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
#include <bits/stdc++.h> using namespace std; #define int long long #define endl '\n' int n, grid[10][10], x, y, v, ans, dp[10][10][50]; signed main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n; while (true) { cin >> x >> y >> v; if (x == y && y == v && v == 0) break; grid[x][y] = v; } for (int k = 1; k <= 2 * n; k++) { for (int i = 1; i <= min(k, n); i++) { for (int j = 1; j <= min(k, n); j++) { dp[i][j][k] = max({dp[i][j][k - 1], dp[i - 1][j][k - 1], dp[i][j - 1][k - 1], dp[i - 1][j - 1][k - 1]}); dp[i][j][k] += grid[i][k - i] + grid[j][k - j]; if (i == j) dp[i][j][k] -= grid[i][k - i]; } } } cout << dp[n][n][2 * n] << endl; return 0; }
这里是题目描述:# [NOIP2000 提高组] 方格取数 ## 题目背景 NOIP 2000 提高组 T4 ## 题目描述 设有 $N \times N$ 的方格图 $(N \le 9)$,我们将其中的某些方格中填入正整数,而其他的方格中则放入数字 $0$。如下图所示(见样例): ![](https://cdn.luogu.com.cn/upload/image_hosting/0bpummja.png) 某人从图的左上角的 $A$ 点出发,可以向下行走,也可以向右走,直到到达右下角的 $B$ 点。在走过的路上,他可以取走方格中的数(取走后的方格中将变为数字 $0$)。 此人从 $A$ 点到 $B$ 点共走两次,试找出 $2$ 条这样的路径,使得取得的数之和为最大。 ## 输入格式 输入的第一行为一个整数 $N$(表示 $N \times N$ 的方格图),接下来的每行有三个整数,前两个表示位置,第三个数为该位置上所放的数。一行单独的 $0$ 表示输入结束。 ## 输出格式 只需输出一个整数,表示 $2$ 条路径上取得的最大的和。 ## 样例 #1 ### 样例输入 #1 ``` 8 2 3 13 2 6 6 3 5 7 4 4 14 5 2 21 5 6 4 6 3 15 7 2 14 0 0 0 ``` ### 样例输出 #1 ``` 67 ``` ## 提示 数据范围:$1\le N\le 9$。 下面是题目解析和做法:第一份题解: ###深搜深搜 见都是动规的帖子,来来来,贴一个深搜的题解(手动滑稽)。。。 这道题深搜的最优方法就是两种方案同时从起点出发。因为如果记录完第一种方案,再计算第二种方案,不可控的因素太多了,大多都不是最优解→\_→,但两种方案同时执行就行,因为这可以根据当前的情况来判断最优。 总的来说,每走一步都会有四个分支(你理解成选择或者情况也可以): 1、两种都向下走 2、第一种向下走,第二种向右走 3、第一种向右走,第二种向下走 4、两种都向右走 每走一步走枚举一下这四种情况,因为在每个点的方案具有唯一性(也就是在某个点走到终点的取数方案只有一个最优解,自己理解一下),所以我们可以开一个数组来记录每一种情况,当重复枚举到一种情况时就直接返回(对,就是剪枝),大大节省了时间(不然会超时哦~)。深搜和动归的时间复杂度时一样的! 附代码: ```cpp //方格取数~深搜 ~( ̄▽ ̄~)(~ ̄▽ ̄)~ #include &lt;iostream &gt;using namespace std; int N=0; int s[15][15],f[11][11][11][11]; int dfs(int x,int y,int x2,int y2)//两种方案同时执行,表示当第一种方案走到x,y,第二种方案走到x2,y2时到终点取得的最大数 { if (f[x][y][x2][y2]!=-1) return f[x][y][x2][y2];//如果这种情况已经被记录过了,直接返回,节省时间 if (x==N &amp;&amp;y==N &amp;&amp;x2==N &amp;&amp;y2==N) return 0;//如果两种方案都走到了终点,返回结束 int M=0; //如果两种方案都不在最后一列,就都往下走,统计取得的数,如果有重复,就减去一部分 if (x &lt;N &amp;&amp;x2 &lt;N) M=max(M,dfs(x+1,y,x2+1,y2)+s[x+1][y]+s[x2+1][y2]-s[x+1][y]*(x+1==x2+1 &amp;&amp;y==y2)); //如果第一种方案不在最后一行,第二种方案不在最后一列,第一种就向下走,第二种就向右走, //统计取得的数,如果有重复,就减去一部分 if (x &lt;N &amp;&amp;y2 &lt;N) M=max(M,dfs(x+1,y,x2,y2+1)+s[x+1][y]+s[x2][y2+1]-s[x+1][y]*(x+1==x2 &amp;&amp;y==y2+1)); //如果第一种方案不在最后一列,第二种方案不在最后一行,第一种就向右走,第二种就向下走, //统计取得的数,如果有重复,就减去一部分 if (y &lt;N &amp;&amp;x2 &lt;N) M=max(M,dfs(x,y+1,x2+1,y2)+s[x][y+1]+s[x2+1][y2]-s[x][y+1]*(x==x2+1 &amp;&amp;y+1==y2)); //如果第一种方案和第二种方案都不在最后一列,就都向右走,统计取得的数,如果有重复,就减去一部分 if (y &lt;N &amp;&amp;y2 &lt;N) M=max(M,dfs(x,y+1,x2,y2+1)+s[x][y+1]+s[x2][y2+1]-s[x][y+1]*(x==x2 &amp;&amp;y+1==y2+1)); //对最后那个 s[x][y+1]*(x==x2 &amp;&amp;y+1==y2+1))的解释:这个是用来判断两种方案是不是走到了同一格的 //如果是真,就返回1,否则返回0,如果是1的话,理所当然的可以减去s[x][y+1]*1,否则减去s[x][y+1]*0相当于 //不减,写得有点精简,省了4个if,见谅哈~ f[x][y][x2][y2]=M;//记录这种情况 return M;//返回最大值 } int main() { cin &gt;&gt;N; //将记录数组初始化成-1,因为可能出现取的数为0的情况,如果直接判断f[x][y][x2][y2]!=0(见dfs第一行) //可能出现死循环而导致超时,细节问题 for(int a=0;a &lt;=N;a++) for(int b=0;b &lt;=N;b++) for(int c=0;c &lt;=N;c++) for(int d=0;d &lt;=N;d++) f[a][b][c][d]=-1; for(;;)//读入 { int t1=0,t2=0,t3=0; cin &gt;&gt;t1 &gt;&gt;t2 &gt;&gt;t3; if(t1==0 &amp;&amp;t2==0 &amp;&amp;t3==0) break; s[t1][t2]=t3; } cout &lt;&lt;dfs(1,1,1,1)+s[1][1];//输出,因为dfs中没有考虑第一格,即s[1][1],所以最后要加一下 return 0; } ``` 第二份题解: 一道典型的棋盘dp。 一共需要走两次,我们不妨同时处理这两条路径。这样,我们既可以方便地处理两条路径重合的情况,也可以减少代码的时间复杂度。 最朴素的想法是开一个四维数组$f[x_1][y_1][x_2][y_2]$表示当两条路径分别处理到$(x_1,y_1)$和$(x_2,y_2)$时能够获得的最大的累积和。但是,四维数组处理起来时间复杂度太大了,所以我们要想办法把它降成三维。 我们可以发现,每当我们走一步,那么x坐标和y坐标之间总会有一个数加$1$。所以,我们可以用k来表示x坐标和y坐标的和,从而通过y坐标来计算出x坐标。由于k对于两条同时处理的路径可以是公共的,所以我们可以用$f[k][y_1][y_2]$来表示当前状态。 特殊的,由于每一个方格的数只可以取一次,所以我们要判断i和j是否相当。 于是,我们就可以得到一个状态转移方程了: $$f[k][i][j]=max(f[k-1][i][j],f[k-1][i-1][j]f[k-1][i][j-1]f[k-1][i-1][j-1])+[(i==j)?map[k-i+1][i]:map[k-i+1][i] + map[k-j+1][j]]$$ 我们可以来看一下我们到底是通过哪些状态转移到当前状态的: ![](https://cdn.luogu.com.cn/upload/pic/71682.png) code: ```cpp #include &lt;iostream &gt;#include &lt;cstring &gt;#include &lt;cstdio &gt;#include &lt;cmath &gt;#include &lt;algorithm &gt;#define ll long long #define INF 0x7fffffff #define re register #define qwq printf(&quot;qwq\n &quot;); using namespace std; int read() { register int x = 0,f = 1;register char ch; ch = getchar(); while(ch &gt;&#039;9 &#039;|| ch &lt;&#039;0 &#039;){if(ch == &#039;-&#039;) f = -f;ch = getchar();} while(ch &lt;= &#039;9 &#039;&amp;&amp;ch &gt;= &#039;0 &#039;){x = x * 10 + ch - 48;ch = getchar();} return x * f; } int n,m,map[205][205],f[205][205][205],x,y,v; int cmp(int a,int b,int c,int d) { a = max(a,b); c = max(c,d); return max(a,c); } int main() { m = read(); n = m; x = read(); y = read(); v = read(); while(x &gt;0) { map[x][y] = v; x = read(); y = read(); v = read(); } for(int k = 1; k &lt;= m + n; k++) for(int i = 1; i &lt;= min(k,n); i++) for(int j = 1; j &lt;= min(k,n); j++) { f[k][i][j] = cmp(f[k - 1][i][j],f[k - 1][i - 1][j],f[k - 1][i][j - 1],f[k - 1][i - 1][j - 1]) + map[k - i + 1][i] + map[k - j + 1][j]; if(i == j) f[k][i][j] -= map[k - i + 1][i]; } f[n + m][n][n] = cmp(f[n + m - 1][n][n - 1],f[n + m - 1][n - 1][n],f[n + m - 1][n][n],f[n + m - 1][n - 1][n - 1]); printf(&quot;%d\n &quot;,f[n + m][n][n]); return 0; } ``` 题目标签:动 态 规 划
#include <bits/stdc++.h> using namespace std; #define int long long #define endl '\n' int n, grid[10][10], x, y, v, ans; typedef struct { int x, y; } node; int dp[10][10], ind[10][10]; node lit[10][10][100]; signed main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n; while (true) { cin >> x >> y >> v; if (x == y && y == v && v == 0) break; else grid[x][y] = v; } for (int i = n; i >= 1; i--) { for (int j = n; j >= 1; j--) { if (grid[i][j]) { lit[i][j][++ind[i][j]].x = i; lit[i][j][ind[i][j]].y = j; } if (!(i < n && j < n)) continue; dp[i][j] = max(dp[i + 1][j], dp[i][j + 1]) + grid[i][j]; if (dp[i][j + 1] >= dp[i + 1][j]) { for (int k = 1; k <= ind[i][j + 1]; k++) lit[i][j][++ind[i][j]] = lit[i][j + 1][k]; } else for (int k = 1; k <= ind[i + 1][j]; k++) lit[i][j][++ind[i][j]] = lit[i + 1][j][k]; } } ans += dp[1][1]; for (int i = 1; i <= ind[1][1]; i++) grid[lit[1][1][i].x][lit[1][1][i].y] = 0; for (int i = n; i >= 1; i--) { for (int j = n; j >= 1; j--) { if (!(i < n && j < n)) continue; dp[i][j] = max(dp[i + 1][j], dp[i][j + 1]) + grid[i][j]; } } ans += dp[1][1]; cout << ans << endl; return 0; }
为我指出下面代码的问题,并修复它。下面是题目描述和题解
README.md exists but content is empty. Use the Edit dataset card button to edit it.
Downloads last month
1
Edit dataset card