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<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int size = 5005;
int a[size];
int main()
{
int L,N;
cin>>L>>N;
if (!N) //特判 N==0的情况
{
cout<<"0 0"<<endl;
return 0;
}
for (int i=1;i<=N;i++) cin>>a[i]; //输入
sort(a+1,a+N+1); //从小到大排序（算最长时间时可能方便一些）
int max_time,min_time;
for (int i=1;i<=N;i++)
min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值
max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走,
//时间较长的那个人的时间 （排序的好处）
cout<<min_time<<' '<<max_time<<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<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int size = 5005;
int a[size];
int main()
{
int L,N;
cin>>L>>N;
if (!N) //特判 N==0的情况
{
cout<<"0 0"<<endl;
return 0;
}
for (int i=1;i<=N;i++) cin>>a[i]; //输入
sort(a+1,a+N+1); //从小到大排序（算最长时间时可能方便一些）
int max_time,min_time;
for (int i=1;i<=N;i++)
min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值
max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走,
//时间较长的那个人的时间 （排序的好处）
cout<<min_time<<' '<<max_time<<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<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int size = 5005;
int a[size];
int main()
{
int L,N;
cin>>L>>N;
if (!N) //特判 N==0的情况
{
cout<<"0 0"<<endl;
return 0;
}
for (int i=1;i<=N;i++) cin>>a[i]; //输入
sort(a+1,a+N+1); //从小到大排序（算最长时间时可能方便一些）
int max_time,min_time;
for (int i=1;i<=N;i++)
min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值
max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走,
//时间较长的那个人的时间 （排序的好处）
cout<<min_time<<' '<<max_time<<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<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int size = 5005;
int a[size];
int main()
{
int L,N;
cin>>L>>N;
if (!N) //特判 N==0的情况
{
cout<<"0 0"<<endl;
return 0;
}
for (int i=1;i<=N;i++) cin>>a[i]; //输入
sort(a+1,a+N+1); //从小到大排序（算最长时间时可能方便一些）
int max_time,min_time;
for (int i=1;i<=N;i++)
min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值
max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走,
//时间较长的那个人的时间 （排序的好处）
cout<<min_time<<' '<<max_time<<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<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int size = 5005;
int a[size];
int main()
{
int L,N;
cin>>L>>N;
if (!N) //特判 N==0的情况
{
cout<<"0 0"<<endl;
return 0;
}
for (int i=1;i<=N;i++) cin>>a[i]; //输入
sort(a+1,a+N+1); //从小到大排序（算最长时间时可能方便一些）
int max_time,min_time;
for (int i=1;i<=N;i++)
min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值
max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走,
//时间较长的那个人的时间 （排序的好处）
cout<<min_time<<' '<<max_time<<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<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int size = 5005;
int a[size];
int main()
{
int L,N;
cin>>L>>N;
if (!N) //特判 N==0的情况
{
cout<<"0 0"<<endl;
return 0;
}
for (int i=1;i<=N;i++) cin>>a[i]; //输入
sort(a+1,a+N+1); //从小到大排序（算最长时间时可能方便一些）
int max_time,min_time;
for (int i=1;i<=N;i++)
min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值
max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走,
//时间较长的那个人的时间 （排序的好处）
cout<<min_time<<' '<<max_time<<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<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int size = 5005;
int a[size];
int main()
{
int L,N;
cin>>L>>N;
if (!N) //特判 N==0的情况
{
cout<<"0 0"<<endl;
return 0;
}
for (int i=1;i<=N;i++) cin>>a[i]; //输入
sort(a+1,a+N+1); //从小到大排序（算最长时间时可能方便一些）
int max_time,min_time;
for (int i=1;i<=N;i++)
min_time=max(min(a[i],L+1-a[i]),min_time); //最短时间就是所有人中走完桥最小值中的最大值
max_time=max(L+1-a[1],a[N]); //最长时间就是最靠近端点两个人各自向对方走,
//时间较长的那个人的时间 （排序的好处）
cout<<min_time<<' '<<max_time<<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 <bits/stdc++.h >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 &x, const info &y)
{
return x.h <y.h;
}
int main()
{
cin >>n >>k;
m = n - k;//选取m本书
for(int i = 1; i <= n; i++)
scanf("%d %d ", &a[i].h, &a[i].w);
sort(a+1, a+n+1, cmp);//高度决定顺序
memset(f, 20, sizeof(f));//初始极大，能缩小就缩小
for(int i = 1; i <= n; i++)
f[i][1] = 0;
//单独选择任何书都不会有花费
for(int i = 2; i <= n; i++)//试着放第i本的时候
for(int j = 1; j <= i-1; j++)//尝试与前面第j本相邻
for(int l = 2; l <= 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 <= n; i++)
Min = min(Min, f[i][m]);//i的循环的意思是：以m结尾的队列，可能最小，以m+1结尾的队列也可能的……以n结尾的队列也可能。
printf("%d\n ", 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 <bits/stdc++.h >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 &x, const info &y)
{
return x.h <y.h;
}
int main()
{
cin >>n >>k;
m = n - k;//选取m本书
for(int i = 1; i <= n; i++)
scanf("%d %d ", &a[i].h, &a[i].w);
sort(a+1, a+n+1, cmp);//高度决定顺序
memset(f, 20, sizeof(f));//初始极大，能缩小就缩小
for(int i = 1; i <= n; i++)
f[i][1] = 0;
//单独选择任何书都不会有花费
for(int i = 2; i <= n; i++)//试着放第i本的时候
for(int j = 1; j <= i-1; j++)//尝试与前面第j本相邻
for(int l = 2; l <= 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 <= n; i++)
Min = min(Min, f[i][m]);//i的循环的意思是：以m结尾的队列，可能最小，以m+1结尾的队列也可能的……以n结尾的队列也可能。
printf("%d\n ", 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 <bits/stdc++.h >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 &x, const info &y)
{
return x.h <y.h;
}
int main()
{
cin >>n >>k;
m = n - k;//选取m本书
for(int i = 1; i <= n; i++)
scanf("%d %d ", &a[i].h, &a[i].w);
sort(a+1, a+n+1, cmp);//高度决定顺序
memset(f, 20, sizeof(f));//初始极大，能缩小就缩小
for(int i = 1; i <= n; i++)
f[i][1] = 0;
//单独选择任何书都不会有花费
for(int i = 2; i <= n; i++)//试着放第i本的时候
for(int j = 1; j <= i-1; j++)//尝试与前面第j本相邻
for(int l = 2; l <= 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 <= n; i++)
Min = min(Min, f[i][m]);//i的循环的意思是：以m结尾的队列，可能最小，以m+1结尾的队列也可能的……以n结尾的队列也可能。
printf("%d\n ", 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 <bits/stdc++.h >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 &x, const info &y)
{
return x.h <y.h;
}
int main()
{
cin >>n >>k;
m = n - k;//选取m本书
for(int i = 1; i <= n; i++)
scanf("%d %d ", &a[i].h, &a[i].w);
sort(a+1, a+n+1, cmp);//高度决定顺序
memset(f, 20, sizeof(f));//初始极大，能缩小就缩小
for(int i = 1; i <= n; i++)
f[i][1] = 0;
//单独选择任何书都不会有花费
for(int i = 2; i <= n; i++)//试着放第i本的时候
for(int j = 1; j <= i-1; j++)//尝试与前面第j本相邻
for(int l = 2; l <= 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 <= n; i++)
Min = min(Min, f[i][m]);//i的循环的意思是：以m结尾的队列，可能最小，以m+1结尾的队列也可能的……以n结尾的队列也可能。
printf("%d\n ", 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 <bits/stdc++.h >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 &x, const info &y)
{
return x.h <y.h;
}
int main()
{
cin >>n >>k;
m = n - k;//选取m本书
for(int i = 1; i <= n; i++)
scanf("%d %d ", &a[i].h, &a[i].w);
sort(a+1, a+n+1, cmp);//高度决定顺序
memset(f, 20, sizeof(f));//初始极大，能缩小就缩小
for(int i = 1; i <= n; i++)
f[i][1] = 0;
//单独选择任何书都不会有花费
for(int i = 2; i <= n; i++)//试着放第i本的时候
for(int j = 1; j <= i-1; j++)//尝试与前面第j本相邻
for(int l = 2; l <= 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 <= n; i++)
Min = min(Min, f[i][m]);//i的循环的意思是：以m结尾的队列，可能最小，以m+1结尾的队列也可能的……以n结尾的队列也可能。
printf("%d\n ", 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 <bits/stdc++.h >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 &x, const info &y)
{
return x.h <y.h;
}
int main()
{
cin >>n >>k;
m = n - k;//选取m本书
for(int i = 1; i <= n; i++)
scanf("%d %d ", &a[i].h, &a[i].w);
sort(a+1, a+n+1, cmp);//高度决定顺序
memset(f, 20, sizeof(f));//初始极大，能缩小就缩小
for(int i = 1; i <= n; i++)
f[i][1] = 0;
//单独选择任何书都不会有花费
for(int i = 2; i <= n; i++)//试着放第i本的时候
for(int j = 1; j <= i-1; j++)//尝试与前面第j本相邻
for(int l = 2; l <= 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 <= n; i++)
Min = min(Min, f[i][m]);//i的循环的意思是：以m结尾的队列，可能最小，以m+1结尾的队列也可能的……以n结尾的队列也可能。
printf("%d\n ", 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 <bits/stdc++.h >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 &x, const info &y)
{
return x.h <y.h;
}
int main()
{
cin >>n >>k;
m = n - k;//选取m本书
for(int i = 1; i <= n; i++)
scanf("%d %d ", &a[i].h, &a[i].w);
sort(a+1, a+n+1, cmp);//高度决定顺序
memset(f, 20, sizeof(f));//初始极大，能缩小就缩小
for(int i = 1; i <= n; i++)
f[i][1] = 0;
//单独选择任何书都不会有花费
for(int i = 2; i <= n; i++)//试着放第i本的时候
for(int j = 1; j <= i-1; j++)//尝试与前面第j本相邻
for(int l = 2; l <= 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 <= n; i++)
Min = min(Min, f[i][m]);//i的循环的意思是：以m结尾的队列，可能最小，以m+1结尾的队列也可能的……以n结尾的队列也可能。
printf("%d\n ", 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 <bits/stdc++.h >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 &x, const info &y)
{
return x.h <y.h;
}
int main()
{
cin >>n >>k;
m = n - k;//选取m本书
for(int i = 1; i <= n; i++)
scanf("%d %d ", &a[i].h, &a[i].w);
sort(a+1, a+n+1, cmp);//高度决定顺序
memset(f, 20, sizeof(f));//初始极大，能缩小就缩小
for(int i = 1; i <= n; i++)
f[i][1] = 0;
//单独选择任何书都不会有花费
for(int i = 2; i <= n; i++)//试着放第i本的时候
for(int j = 1; j <= i-1; j++)//尝试与前面第j本相邻
for(int l = 2; l <= 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 <= n; i++)
Min = min(Min, f[i][m]);//i的循环的意思是：以m结尾的队列，可能最小，以m+1结尾的队列也可能的……以n结尾的队列也可能。
printf("%d\n ", 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 <bits/stdc++.h >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 &x, const info &y)
{
return x.h <y.h;
}
int main()
{
cin >>n >>k;
m = n - k;//选取m本书
for(int i = 1; i <= n; i++)
scanf("%d %d ", &a[i].h, &a[i].w);
sort(a+1, a+n+1, cmp);//高度决定顺序
memset(f, 20, sizeof(f));//初始极大，能缩小就缩小
for(int i = 1; i <= n; i++)
f[i][1] = 0;
//单独选择任何书都不会有花费
for(int i = 2; i <= n; i++)//试着放第i本的时候
for(int j = 1; j <= i-1; j++)//尝试与前面第j本相邻
for(int l = 2; l <= 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 <= n; i++)
Min = min(Min, f[i][m]);//i的循环的意思是：以m结尾的队列，可能最小，以m+1结尾的队列也可能的……以n结尾的队列也可能。
printf("%d\n ", 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 < k \le N$ ，而 $1+(k-1)=k$ ，矛盾。
其它 $> 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 < k \le N$ ，而 $1+(k-1)=k$ ，矛盾。
其它 $> 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 < k \le N$ ，而 $1+(k-1)=k$ ，矛盾。
其它 $> 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 < k \le N$ ，而 $1+(k-1)=k$ ，矛盾。
其它 $> 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 < k \le N$ ，而 $1+(k-1)=k$ ，矛盾。
其它 $> 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 < k \le N$ ，而 $1+(k-1)=k$ ，矛盾。
其它 $> 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 < k \le N$ ，而 $1+(k-1)=k$ ，矛盾。
其它 $> 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$。如下图所示（见样例）:
某人从图的左上角的 $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 <iostream >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 &&y==N &&x2==N &&y2==N) return 0;//如果两种方案都走到了终点，返回结束
int M=0;
//如果两种方案都不在最后一列，就都往下走，统计取得的数，如果有重复，就减去一部分
if (x <N &&x2 <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 &&y==y2));
//如果第一种方案不在最后一行，第二种方案不在最后一列，第一种就向下走，第二种就向右走，
//统计取得的数，如果有重复，就减去一部分
if (x <N &&y2 <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 &&y==y2+1));
//如果第一种方案不在最后一列，第二种方案不在最后一行，第一种就向右走，第二种就向下走，
//统计取得的数，如果有重复，就减去一部分
if (y <N &&x2 <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 &&y+1==y2));
//如果第一种方案和第二种方案都不在最后一列，就都向右走，统计取得的数，如果有重复，就减去一部分
if (y <N &&y2 <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 &&y+1==y2+1));
//对最后那个 s[x][y+1]*(x==x2 &&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 >>N;
//将记录数组初始化成-1，因为可能出现取的数为0的情况，如果直接判断f[x][y][x2][y2]!=0（见dfs第一行）
//可能出现死循环而导致超时，细节问题
for(int a=0;a <=N;a++)
for(int b=0;b <=N;b++)
for(int c=0;c <=N;c++)
for(int d=0;d <=N;d++) f[a][b][c][d]=-1;
for(;;)//读入
{
int t1=0,t2=0,t3=0;
cin >>t1 >>t2 >>t3;
if(t1==0 &&t2==0 &&t3==0) break;
s[t1][t2]=t3;
}
cout <<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]]$$
我们可以来看一下我们到底是通过哪些状态转移到当前状态的：
code:
```cpp
#include <iostream >#include <cstring >#include <cstdio >#include <cmath >#include <algorithm >#define ll long long
#define INF 0x7fffffff
#define re register
#define qwq printf("qwq\n ");
using namespace std;
int read()
{
register int x = 0,f = 1;register char ch;
ch = getchar();
while(ch >'9 '|| ch <'0 '){if(ch == '-') f = -f;ch = getchar();}
while(ch <= '9 '&&ch >= '0 '){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 >0)
{
map[x][y] = v;
x = read(); y = read(); v = read();
}
for(int k = 1; k <= m + n; k++)
for(int i = 1; i <= min(k,n); i++)
for(int j = 1; j <= 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("%d\n ",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$。如下图所示（见样例）:
某人从图的左上角的 $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 <iostream >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 &&y==N &&x2==N &&y2==N) return 0;//如果两种方案都走到了终点，返回结束
int M=0;
//如果两种方案都不在最后一列，就都往下走，统计取得的数，如果有重复，就减去一部分
if (x <N &&x2 <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 &&y==y2));
//如果第一种方案不在最后一行，第二种方案不在最后一列，第一种就向下走，第二种就向右走，
//统计取得的数，如果有重复，就减去一部分
if (x <N &&y2 <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 &&y==y2+1));
//如果第一种方案不在最后一列，第二种方案不在最后一行，第一种就向右走，第二种就向下走，
//统计取得的数，如果有重复，就减去一部分
if (y <N &&x2 <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 &&y+1==y2));
//如果第一种方案和第二种方案都不在最后一列，就都向右走，统计取得的数，如果有重复，就减去一部分
if (y <N &&y2 <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 &&y+1==y2+1));
//对最后那个 s[x][y+1]*(x==x2 &&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 >>N;
//将记录数组初始化成-1，因为可能出现取的数为0的情况，如果直接判断f[x][y][x2][y2]!=0（见dfs第一行）
//可能出现死循环而导致超时，细节问题
for(int a=0;a <=N;a++)
for(int b=0;b <=N;b++)
for(int c=0;c <=N;c++)
for(int d=0;d <=N;d++) f[a][b][c][d]=-1;
for(;;)//读入
{
int t1=0,t2=0,t3=0;
cin >>t1 >>t2 >>t3;
if(t1==0 &&t2==0 &&t3==0) break;
s[t1][t2]=t3;
}
cout <<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]]$$
我们可以来看一下我们到底是通过哪些状态转移到当前状态的：
code:
```cpp
#include <iostream >#include <cstring >#include <cstdio >#include <cmath >#include <algorithm >#define ll long long
#define INF 0x7fffffff
#define re register
#define qwq printf("qwq\n ");
using namespace std;
int read()
{
register int x = 0,f = 1;register char ch;
ch = getchar();
while(ch >'9 '|| ch <'0 '){if(ch == '-') f = -f;ch = getchar();}
while(ch <= '9 '&&ch >= '0 '){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 >0)
{
map[x][y] = v;
x = read(); y = read(); v = read();
}
for(int k = 1; k <= m + n; k++)
for(int i = 1; i <= min(k,n); i++)
for(int j = 1; j <= 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("%d\n ",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$。如下图所示（见样例）:
某人从图的左上角的 $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 <iostream >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 &&y==N &&x2==N &&y2==N) return 0;//如果两种方案都走到了终点，返回结束
int M=0;
//如果两种方案都不在最后一列，就都往下走，统计取得的数，如果有重复，就减去一部分
if (x <N &&x2 <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 &&y==y2));
//如果第一种方案不在最后一行，第二种方案不在最后一列，第一种就向下走，第二种就向右走，
//统计取得的数，如果有重复，就减去一部分
if (x <N &&y2 <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 &&y==y2+1));
//如果第一种方案不在最后一列，第二种方案不在最后一行，第一种就向右走，第二种就向下走，
//统计取得的数，如果有重复，就减去一部分
if (y <N &&x2 <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 &&y+1==y2));
//如果第一种方案和第二种方案都不在最后一列，就都向右走，统计取得的数，如果有重复，就减去一部分
if (y <N &&y2 <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 &&y+1==y2+1));
//对最后那个 s[x][y+1]*(x==x2 &&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 >>N;
//将记录数组初始化成-1，因为可能出现取的数为0的情况，如果直接判断f[x][y][x2][y2]!=0（见dfs第一行）
//可能出现死循环而导致超时，细节问题
for(int a=0;a <=N;a++)
for(int b=0;b <=N;b++)
for(int c=0;c <=N;c++)
for(int d=0;d <=N;d++) f[a][b][c][d]=-1;
for(;;)//读入
{
int t1=0,t2=0,t3=0;
cin >>t1 >>t2 >>t3;
if(t1==0 &&t2==0 &&t3==0) break;
s[t1][t2]=t3;
}
cout <<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]]$$
我们可以来看一下我们到底是通过哪些状态转移到当前状态的：
code:
```cpp
#include <iostream >#include <cstring >#include <cstdio >#include <cmath >#include <algorithm >#define ll long long
#define INF 0x7fffffff
#define re register
#define qwq printf("qwq\n ");
using namespace std;
int read()
{
register int x = 0,f = 1;register char ch;
ch = getchar();
while(ch >'9 '|| ch <'0 '){if(ch == '-') f = -f;ch = getchar();}
while(ch <= '9 '&&ch >= '0 '){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 >0)
{
map[x][y] = v;
x = read(); y = read(); v = read();
}
for(int k = 1; k <= m + n; k++)
for(int i = 1; i <= min(k,n); i++)
for(int j = 1; j <= 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("%d\n ",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;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#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$。如下图所示（见样例）:
某人从图的左上角的 $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 <iostream >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 &&y==N &&x2==N &&y2==N) return 0;//如果两种方案都走到了终点，返回结束
int M=0;
//如果两种方案都不在最后一列，就都往下走，统计取得的数，如果有重复，就减去一部分
if (x <N &&x2 <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 &&y==y2));
//如果第一种方案不在最后一行，第二种方案不在最后一列，第一种就向下走，第二种就向右走，
//统计取得的数，如果有重复，就减去一部分
if (x <N &&y2 <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 &&y==y2+1));
//如果第一种方案不在最后一列，第二种方案不在最后一行，第一种就向右走，第二种就向下走，
//统计取得的数，如果有重复，就减去一部分
if (y <N &&x2 <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 &&y+1==y2));
//如果第一种方案和第二种方案都不在最后一列，就都向右走，统计取得的数，如果有重复，就减去一部分
if (y <N &&y2 <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 &&y+1==y2+1));
//对最后那个 s[x][y+1]*(x==x2 &&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 >>N;
//将记录数组初始化成-1，因为可能出现取的数为0的情况，如果直接判断f[x][y][x2][y2]!=0（见dfs第一行）
//可能出现死循环而导致超时，细节问题
for(int a=0;a <=N;a++)
for(int b=0;b <=N;b++)
for(int c=0;c <=N;c++)
for(int d=0;d <=N;d++) f[a][b][c][d]=-1;
for(;;)//读入
{
int t1=0,t2=0,t3=0;
cin >>t1 >>t2 >>t3;
if(t1==0 &&t2==0 &&t3==0) break;
s[t1][t2]=t3;
}
cout <<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]]$$
我们可以来看一下我们到底是通过哪些状态转移到当前状态的：
code:
```cpp
#include <iostream >#include <cstring >#include <cstdio >#include <cmath >#include <algorithm >#define ll long long
#define INF 0x7fffffff
#define re register
#define qwq printf("qwq\n ");
using namespace std;
int read()
{
register int x = 0,f = 1;register char ch;
ch = getchar();
while(ch >'9 '|| ch <'0 '){if(ch == '-') f = -f;ch = getchar();}
while(ch <= '9 '&&ch >= '0 '){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 >0)
{
map[x][y] = v;
x = read(); y = read(); v = read();
}
for(int k = 1; k <= m + n; k++)
for(int i = 1; i <= min(k,n); i++)
for(int j = 1; j <= 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("%d\n ",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, 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 - 2; k++)
{
for (int i = 1; i <= min(1 + k, n); i++)
{
for (int j = 1; j <= min(1 + 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 + 1] + grid[j][k - j + 1];
if (i == j)
dp[i][j][k] -= grid[i][k - i + 1];
}
}
}
cout << dp[n][n][2 * n - 2] << endl;
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <iostream>
#include <vector>
using namespace std;
using pi = pair<int, int>;
using ll = long long;
const int N = 10;
int dp[N][N][N][N];
int map[N][N];
int main()
{
int n;
cin >> n;
int a, b, c;
cin >> a >> b >> c;
while (!(a == 0 && b == 0 && c == 0))
{
map[a][b] = c;
cin >> a >> b >> c;
}
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= n; ++j)
{
for (int p = 1; p <= n; ++p)
{
for (int q = 1; q <= n; ++q)
{
dp[i][j][p][q] = max(dp[i - 1][j][p - 1][q] + map[i][j] + map[p][q], dp[i][j][p][q]);
dp[i][j][p][q] = max(dp[i][j - 1][p - 1][q] + map[i][j] + map[p][q], dp[i][j][p][q]);
dp[i][j][p][q] = max(dp[i - 1][j][p][q - 1] + map[i][j] + map[p][q], dp[i][j][p][q]);
dp[i][j][p][q] = max(dp[i][j - 1][p][q - 1] + map[i][j] + map[p][q], dp[i][j][p][q]);
if (i == p && j == q)
dp[i][j][p][q] -= map[i][j];
}
}
}
}
cout << dp[n][n][n][n] << endl;
return 0;
} | 这里是题目描述：# [NOIP2000 提高组] 方格取数
## 题目背景
NOIP 2000 提高组 T4
## 题目描述
设有 $N \times N$ 的方格图 $(N \le 9)$，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字 $0$。如下图所示（见样例）:
某人从图的左上角的 $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 <iostream >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 &&y==N &&x2==N &&y2==N) return 0;//如果两种方案都走到了终点，返回结束
int M=0;
//如果两种方案都不在最后一列，就都往下走，统计取得的数，如果有重复，就减去一部分
if (x <N &&x2 <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 &&y==y2));
//如果第一种方案不在最后一行，第二种方案不在最后一列，第一种就向下走，第二种就向右走，
//统计取得的数，如果有重复，就减去一部分
if (x <N &&y2 <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 &&y==y2+1));
//如果第一种方案不在最后一列，第二种方案不在最后一行，第一种就向右走，第二种就向下走，
//统计取得的数，如果有重复，就减去一部分
if (y <N &&x2 <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 &&y+1==y2));
//如果第一种方案和第二种方案都不在最后一列，就都向右走，统计取得的数，如果有重复，就减去一部分
if (y <N &&y2 <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 &&y+1==y2+1));
//对最后那个 s[x][y+1]*(x==x2 &&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 >>N;
//将记录数组初始化成-1，因为可能出现取的数为0的情况，如果直接判断f[x][y][x2][y2]!=0（见dfs第一行）
//可能出现死循环而导致超时，细节问题
for(int a=0;a <=N;a++)
for(int b=0;b <=N;b++)
for(int c=0;c <=N;c++)
for(int d=0;d <=N;d++) f[a][b][c][d]=-1;
for(;;)//读入
{
int t1=0,t2=0,t3=0;
cin >>t1 >>t2 >>t3;
if(t1==0 &&t2==0 &&t3==0) break;
s[t1][t2]=t3;
}
cout <<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]]$$
我们可以来看一下我们到底是通过哪些状态转移到当前状态的：
code:
```cpp
#include <iostream >#include <cstring >#include <cstdio >#include <cmath >#include <algorithm >#define ll long long
#define INF 0x7fffffff
#define re register
#define qwq printf("qwq\n ");
using namespace std;
int read()
{
register int x = 0,f = 1;register char ch;
ch = getchar();
while(ch >'9 '|| ch <'0 '){if(ch == '-') f = -f;ch = getchar();}
while(ch <= '9 '&&ch >= '0 '){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 >0)
{
map[x][y] = v;
x = read(); y = read(); v = read();
}
for(int k = 1; k <= m + n; k++)
for(int i = 1; i <= min(k,n); i++)
for(int j = 1; j <= 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("%d\n ",f[n + m][n][n]);
return 0;
}
``` 题目标签：动 态 规 划 | #include <iostream>
#include <vector>
using namespace std;
using pi = pair<int, int>;
using ll = long long;
const int N = 10;
int dp[N][N][N][N];
int map[N][N];
int main()
{
int n;
cin >> n;
int a, b, c;
cin >> a >> b >> c;
while (!(a == 0 && b == 0 && c == 0))
{
map[a][b] = c;
cin >> a >> b >> c;
}
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= n; ++j)
{
for (int p = 1; p <= n; ++p)
{
for (int q = 1; q <= n; ++q)
{
dp[i][j][p][q] = max(dp[i - 1][j][p][q] + map[i][j] + map[p][q], dp[i][j][p][q]);
dp[i][j][p][q] = max(dp[i][j - 1][p][q] + map[i][j] + map[p][q], dp[i][j][p][q]);
dp[i][j][p][q] = max(dp[i][j][p - 1][q] + map[i][j] + map[p][q], dp[i][j][p][q]);
dp[i][j][p][q] = max(dp[i][j][p][q - 1] + map[i][j] + map[p][q], dp[i][j][p][q]);
if (i == p && j == q)
dp[i][j][p][q] -= map[i][j];
}
}
}
}
cout << dp[n][n][n][n] << endl;
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 15;
int f[2 * N][N][N], w[N][N];
int n, a, b, c;
int main()
{
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
while (cin >> a >> b >> c, a || b || c)
w[a][b] = c;
for (int k = 2; k <= 2 * n; k++)
for (int i1 = 1; i1 <= n; i1++)
for (int i2 = 1; i2 <= n; i2++)
{
int j1 = k - i1, j2 = k - i2;
if (j1 >= 1 && j1 <= n && j2 >= 1 && j2 <= n)
{
int t = w[i1][j1];
if (i1 != i2)
t += w[i2][j2];
f[k][i1][i2] = max(f[k - 1][i1][i2] + t, f[k][i1][i2]);
f[k][i1][i2] = max(f[k - 1][i1 - 1][i2] + t, f[k][i1][i2]);
f[k][i1][i2] = max(f[k - 1][i1][i2 - 1] + t, f[k][i1][i2]);
f[k][i1][i2] = max(f[k - 1][i1 - 1][i2 - 1] + t, f[k][i1][i2]);
}
}
cout << f[2 * n][n][n] << '\n';
return 0;
} | 这里是题目描述：# [NOIP2000 提高组] 方格取数
## 题目背景
NOIP 2000 提高组 T4
## 题目描述
设有 $N \times N$ 的方格图 $(N \le 9)$，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字 $0$。如下图所示（见样例）:
某人从图的左上角的 $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 <iostream >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 &&y==N &&x2==N &&y2==N) return 0;//如果两种方案都走到了终点，返回结束
int M=0;
//如果两种方案都不在最后一列，就都往下走，统计取得的数，如果有重复，就减去一部分
if (x <N &&x2 <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 &&y==y2));
//如果第一种方案不在最后一行，第二种方案不在最后一列，第一种就向下走，第二种就向右走，
//统计取得的数，如果有重复，就减去一部分
if (x <N &&y2 <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 &&y==y2+1));
//如果第一种方案不在最后一列，第二种方案不在最后一行，第一种就向右走，第二种就向下走，
//统计取得的数，如果有重复，就减去一部分
if (y <N &&x2 <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 &&y+1==y2));
//如果第一种方案和第二种方案都不在最后一列，就都向右走，统计取得的数，如果有重复，就减去一部分
if (y <N &&y2 <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 &&y+1==y2+1));
//对最后那个 s[x][y+1]*(x==x2 &&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 >>N;
//将记录数组初始化成-1，因为可能出现取的数为0的情况，如果直接判断f[x][y][x2][y2]!=0（见dfs第一行）
//可能出现死循环而导致超时，细节问题
for(int a=0;a <=N;a++)
for(int b=0;b <=N;b++)
for(int c=0;c <=N;c++)
for(int d=0;d <=N;d++) f[a][b][c][d]=-1;
for(;;)//读入
{
int t1=0,t2=0,t3=0;
cin >>t1 >>t2 >>t3;
if(t1==0 &&t2==0 &&t3==0) break;
s[t1][t2]=t3;
}
cout <<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]]$$
我们可以来看一下我们到底是通过哪些状态转移到当前状态的：
code:
```cpp
#include <iostream >#include <cstring >#include <cstdio >#include <cmath >#include <algorithm >#define ll long long
#define INF 0x7fffffff
#define re register
#define qwq printf("qwq\n ");
using namespace std;
int read()
{
register int x = 0,f = 1;register char ch;
ch = getchar();
while(ch >'9 '|| ch <'0 '){if(ch == '-') f = -f;ch = getchar();}
while(ch <= '9 '&&ch >= '0 '){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 >0)
{
map[x][y] = v;
x = read(); y = read(); v = read();
}
for(int k = 1; k <= m + n; k++)
for(int i = 1; i <= min(k,n); i++)
for(int j = 1; j <= 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("%d\n ",f[n + m][n][n]);
return 0;
}
``` 题目标签：动 态 规 划 | #include <iostream>
#include <algorithm>
using namespace std;
const int N = 55;
int f[2 * N][N][N], w[N][N];
int n, m;
int main()
{
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
cin >> w[i][j];
for (int k = 2; k <= n + m; k++)
for (int i1 = 1; i1 <= n; i1++)
for (int i2 = 1; i2 <= n; i2++)
{
int j1 = k - i1, j2 = k - i2;
if (j1 >= 1 && j1 <= m && j2 >= 1 && j2 <= m)
{
int t = w[i1][j1];
if (i1 != i2)
t += w[i2][j2];
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1 - 1][i2 - 1] + t);
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1][i2 - 1] + t);
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1 - 1][i2] + t);
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1][i2] + t);
}
}
cout << f[n + m][n][n] << '\n';
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
/* Zhiyu_
*/
#include <bits/stdc++.h>
using namespace std;
#define iosjs ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define fp(x, a) for (int(x) = 1; (x) <= (a); (x)++)
#define fd(x, a) for (int(x) = (a); (x) >= 1; (x)--)
#define ffp(i, a, b) for (int i = (a); i <= (b); i++)
#define ffd(i, a, b) for (int i = (b); i >= (a); i--)
#define srarr fp(i, n) cin >> arr[i];
#define baoliu(x) fixed << setprecision(x)
int maxabc(int a, int b, int c) { return max(max(a, b), c); }
int minabc(int a, int b, int c) { return min(min(a, b), c); }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); // 随机
map<int, int>::iterator itmap;
vector<int>::iterator itve;
set<int>::iterator itset;
#define inf 0x3f3f3f3f
#define MAXN (200000 + 10)
typedef long long ll;
typedef double dd;
int n, m, arr[MAXN];
int dt[23][23];
int dp[23][23][23][23];
int main()
{
cin >> n;
int a, b, c;
while (cin >> a >> b >> c)
{
if (a == 0 && b == 0 && c == 0)
{ // a|b|c=0;
break;
}
dt[a][b] = c;
}
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
{
for (int ii = 1; ii <= n; ii++)
{
for (int jj = 1; jj <= n; jj++)
{
dp[i][j][ii][jj] = max(max(dp[i - 1][j][ii - 1][jj], dp[i - 1][j][ii][jj - 1]), max(dp[i][j - 1][ii - 1][jj], dp[i][j - 1][ii][jj - 1])) + dt[i][j];
if (i != ii || j != jj)
{
dp[i][j][ii][jj] += dt[ii][jj];
}
}
}
}
}
cout << dp[n][n][n][n] << endl;
return 0;
}
| 这里是题目描述：# [NOIP2000 提高组] 方格取数
## 题目背景
NOIP 2000 提高组 T4
## 题目描述
设有 $N \times N$ 的方格图 $(N \le 9)$，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字 $0$。如下图所示（见样例）:
某人从图的左上角的 $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 <iostream >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 &&y==N &&x2==N &&y2==N) return 0;//如果两种方案都走到了终点，返回结束
int M=0;
//如果两种方案都不在最后一列，就都往下走，统计取得的数，如果有重复，就减去一部分
if (x <N &&x2 <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 &&y==y2));
//如果第一种方案不在最后一行，第二种方案不在最后一列，第一种就向下走，第二种就向右走，
//统计取得的数，如果有重复，就减去一部分
if (x <N &&y2 <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 &&y==y2+1));
//如果第一种方案不在最后一列，第二种方案不在最后一行，第一种就向右走，第二种就向下走，
//统计取得的数，如果有重复，就减去一部分
if (y <N &&x2 <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 &&y+1==y2));
//如果第一种方案和第二种方案都不在最后一列，就都向右走，统计取得的数，如果有重复，就减去一部分
if (y <N &&y2 <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 &&y+1==y2+1));
//对最后那个 s[x][y+1]*(x==x2 &&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 >>N;
//将记录数组初始化成-1，因为可能出现取的数为0的情况，如果直接判断f[x][y][x2][y2]!=0（见dfs第一行）
//可能出现死循环而导致超时，细节问题
for(int a=0;a <=N;a++)
for(int b=0;b <=N;b++)
for(int c=0;c <=N;c++)
for(int d=0;d <=N;d++) f[a][b][c][d]=-1;
for(;;)//读入
{
int t1=0,t2=0,t3=0;
cin >>t1 >>t2 >>t3;
if(t1==0 &&t2==0 &&t3==0) break;
s[t1][t2]=t3;
}
cout <<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]]$$
我们可以来看一下我们到底是通过哪些状态转移到当前状态的：
code:
```cpp
#include <iostream >#include <cstring >#include <cstdio >#include <cmath >#include <algorithm >#define ll long long
#define INF 0x7fffffff
#define re register
#define qwq printf("qwq\n ");
using namespace std;
int read()
{
register int x = 0,f = 1;register char ch;
ch = getchar();
while(ch >'9 '|| ch <'0 '){if(ch == '-') f = -f;ch = getchar();}
while(ch <= '9 '&&ch >= '0 '){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 >0)
{
map[x][y] = v;
x = read(); y = read(); v = read();
}
for(int k = 1; k <= m + n; k++)
for(int i = 1; i <= min(k,n); i++)
for(int j = 1; j <= 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("%d\n ",f[n + m][n][n]);
return 0;
}
``` 题目标签：动 态 规 划 | /* Zhiyu_
*/
#include <bits/stdc++.h>
using namespace std;
#define iosjs ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define fp(x, a) for (int(x) = 1; (x) <= (a); (x)++)
#define fd(x, a) for (int(x) = (a); (x) >= 1; (x)--)
#define ffp(i, a, b) for (int i = (a); i <= (b); i++)
#define ffd(i, a, b) for (int i = (b); i >= (a); i--)
#define srarr fp(i, n) cin >> arr[i];
#define baoliu(x) fixed << setprecision(x)
int maxabc(int a, int b, int c) { return max(max(a, b), c); }
int minabc(int a, int b, int c) { return min(min(a, b), c); }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); // 随机
map<int, int>::iterator itmap;
vector<int>::iterator itve;
set<int>::iterator itset;
#define inf 0x3f3f3f3f
#define MAXN (200000 + 10)
typedef long long ll;
typedef double dd;
int n, m, arr[MAXN];
int dt[23][23];
int dp[23][23][23][23];
int main()
{
cin >> n;
int a, b, c;
cin >> a >> b >> c;
while (cin >> a >> b >> c)
{
if (a == 0 && b == 0 && c == 0)
{ // a|b|c=0;
break;
}
dt[a][b] = c;
}
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
{
for (int ii = 1; ii <= n; ii++)
{
for (int jj = 1; jj <= n; jj++)
{
dp[i][j][ii][jj] = max(max(dp[i - 1][j][ii - 1][jj], dp[i - 1][j][ii][jj - 1]), max(dp[i][j - 1][ii - 1][jj], dp[i][j - 1][ii][jj - 1])) + dt[i][j];
if (i != ii || j != jj)
{
dp[i][j][ii][jj] += dt[ii][jj];
}
}
}
}
}
cout << dp[n][n][n][n] << endl;
return 0;
}
| 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 7;
int n, m, k, s[N], tot, Hash[N], build[N], ans[N];
vector<int> e[N];
int find_(int x) { return x == s[x] ? x : s[x] = find_(s[x]); }
void merge_(int x, int y)
{
int fx = find_(x), fy = find_(y);
if (fx == fy)
return;
s[fx] = s[fy];
tot--;
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
s[i] = i;
tot = n;
for (int i = 1; i <= m; i++)
{
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
scanf("%d", &k);
tot -= k;
for (int i = 1; i <= k; i++)
{
scanf("%d", &build[i]);
Hash[build[i]] = 1;
}
for (int u = 0; u < n; u++)
if (!Hash[u])
for (auto v : e[u])
if (!Hash[v])
merge_(u, v);
for (int i = k; i >= 1; i--)
{
ans[i] = tot++;
int u = build[i];
Hash[u] = 0;
for (auto v : e[u])
if (!Hash[v])
merge_(u, v);
}
ans[0] = tot;
for (int i = 0; i <= k; i++)
cout << ans[i] << endl;
return 0;
} | 这里是题目描述：# [JSOI2008] 星球大战
## 题目描述
很久以前，在一个遥远的星系，一个黑暗的帝国靠着它的超级武器统治着整个星系。
某一天，凭着一个偶然的机遇，一支反抗军摧毁了帝国的超级武器，并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直接或间接地连接。
但好景不长，很快帝国又重新造出了他的超级武器。凭借这超级武器的力量，帝国开始有计划地摧毁反抗军占领的星球。由于星球的不断被摧毁，两个星球之间的通讯通道也开始不可靠起来。
现在，反抗军首领交给你一个任务：给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序，以尽量快的速度求出每一次打击之后反抗军占据的星球的连通块的个数。（如果两个星球可以通过现存的以太通道直接或间接地连通，则这两个星球在同一个连通块中）。
## 输入格式
输入文件第一行包含两个整数，$n,m$，分别表示星球的数目和以太隧道的数目。星球用 $0 \sim n-1$ 的整数编号。
接下来的 $m$ 行，每行包括两个整数 $x,y$，表示星球 $x$ 和星球 $y$ 之间有 “以太” 隧道，可以直接通讯。
接下来的一行为一个整数 $k$ ，表示将遭受攻击的星球的数目。
接下来的 $k$ 行，每行有一个整数，按照顺序列出了帝国军的攻击目标。这 $k$ 个数互不相同，且都在 $0$ 到 $n-1$ 的范围内。
## 输出格式
第一行是开始时星球的连通块个数。接下来的 $k$ 行，每行一个整数，表示经过该次打击后现存星球的连通块个数。
## 样例 #1
### 样例输入 #1
```
8 13
0 1
1 6
6 5
5 0
0 6
1 2
2 3
3 4
4 5
7 1
7 2
7 6
3 6
5
1
6
3
5
7
```
### 样例输出 #1
```
1
1
1
2
3
3
```
## 提示
【数据范围】
对于 $100\%$ 的数据，$1\le m \le 2\times 10^5$，$1\le n \le 2m$，$x \neq y$。
[JSOI2008] 下面是题目解析和做法：第一份题解：
这道题看似很长其实也不是十分的难
如果我们去正这摧毁 想想都有点困难
要不 我们使用逆向思维？
没错 这道题就把摧毁转换成修建~~（和平就是好）~~
利用并查集判断联通就好了
```cpp
#include<iostream>
#include<cstdio>
#define f(i,a,b) for(register int i=a;i<=b;i++)
#define fd(i,a,b) for(register int i=a;i>=b;i--)
using namespace std;
int k,n,m,head[400002],tot,broken[400002],ans[400003];
int father[400003];
struct Node
{
int next,node,from;
}h[400002];
inline void Add_Node(int u,int v)
{
h[++tot].from=u;
h[tot].next=head[u];
head[u]=tot;
h[tot].node=v;
}
bool Broken[400001];
inline int Get_father(int x)
{
if(father[x]==x) return x;
return father[x]=Get_father(father[x]);
//你爸爸的爸爸就是你的爸爸——反查理马特——并查集
}
inline void hb(int u,int v)
{
u=Get_father(u),v=Get_father(v);
if(u!=v) father[v]=u;
}
int main()
{
ios::sync_with_stdio(false);
cin>>n>>m;
f(i,0,n)
father[i]=i,head[i]=-1;//并查集初始化
f(i,1,m)
{
int x,y;
cin>>x>>y;
Add_Node(x,y);//储存图
Add_Node(y,x);//由于无向图存两遍
}
cin>>k;
f(i,1,k)
{
cin>>broken[i];
Broken[broken[i]]=1;//标记砸坏了
}
int total=n-k;//初始化为所有点都是单独存在的
f(i,1,2*m)//有2*m个边
if(!Broken[h[i].from] && !Broken[h[i].node] && Get_father(h[i].from)!=Get_father(h[i].node))
{//要是起点和终点都没砸坏 而且他们并没有联通
total--;//连一条边 减一个联通体
hb(h[i].from,h[i].node);
}
ans[k+1]=total;//当前就是最后一次破坏后的个数
fd(i,k,1)
{
//total=0 //这里不需要初始化 需要从上一次的废墟上修建
total++;//修复一个点 联通体+1
Broken[broken[i]]=0;//修复
for(int j=head[broken[i]];j!=-1;j=h[j].next)//枚举每一个子点
{
if(!Broken[h[j].node] && Get_father(broken[i])!=Get_father(h[j].node))
{
total--;//连一边减一个联通块
hb(broken[i],h[j].node);//合并这两个点
}
}
ans[i]=total;
}
f(i,1,k+1) cout<<ans[i]<<endl;
return 0;
}
```
第二个题解：
题目标签：并 查 集 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, m, k, s[N], tot, Hash[N], build[N], ans[N];
vector<int> e[N];
int find_(int x) { return x == s[x] ? x : find_(s[x]); }
void merge_(int x, int y)
{
int fx = find_(x), fy = find_(y);
if (fx == fy)
return;
s[fx] = s[fy];
tot--;
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
s[i] = i;
tot = n;
for (int i = 1; i <= m; i++)
{
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
scanf("%d", &k);
tot -= k;
for (int i = 1; i <= k; i++)
{
scanf("%d", &build[i]);
Hash[build[i]] = 1;
}
for (int u = 0; u < n; u++)
if (!Hash[u])
for (auto v : e[u])
if (!Hash[v])
merge_(u, v);
for (int i = k; i >= 1; i--)
{
ans[i] = tot++;
int u = build[i];
Hash[u] = 0;
for (auto v : e[u])
if (!Hash[v])
merge_(u, v);
}
for (int i = 1; i <= k; i++)
cout << ans[i] << endl;
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using namespace std;
#define itn int
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<ll, ll> PLL;
#define x first
#define y second
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define lep(i, a, b) for (int i = (a); i >= (b); i--)
#define sci(x) cin >> (x)
#define pri(x) cout << (x) << " ";
#define prl(x) cout << (x) << '\n';
#define pli(x) cout << (x) << " ";
#define pll(x) cout << (x) << '\n';
#define mem(a, x) memset(a, x, sizeof a)
#define mep(a, x) memcpy(a, x, sizeof x)
#define yes cout << "YES" << '\n';
#define no cout << "NO" << '\n';
#define ls u << 1
#define rs u << 1 | 1
// cout << "? " << << ' ';
// printf("case:%d %d\n", );
const int N = 1e6 + 10;
// const ll p = 1e9 + 7;
ll n, m, k;
ll b[N], f[N], p[N], a[N];
char s[N], t[N];
vector<int> e[N];
PLL tr[N];
int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }
void solve()
{
cin >> n >> m;
ll res = 0;
rep(i, 0, n - 1) p[i] = i;
rep(i, 1, m)
{
ll x, y;
cin >> x >> y;
e[x].push_back(y), e[y].push_back(x);
tr[i] = {x, y};
}
sci(k);
rep(i, 1, k) sci(a[i]), b[a[i]] = 1;
rep(i, 1, m) if (!b[tr[i].x] && !b[tr[i].y]) p[find(tr[i].x)] = find(tr[i].y);
rep(i, 0, n - 1) if (!b[i] && i == find(i))++ res; // pll(res)
f[k + 1] = res;
lep(i, k, 1)
{
++res;
for (auto j : e[a[i]])
{
if (b[j] == 1)
continue;
if (find(j) != find(a[i]))
--res;
p[find(j)] = find(a[i]);
}
f[i] = res;
b[a[i]] = 0;
}
rep(i, 1, k + 1) pll(f[i])
}
signed main()
{
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int T;
T = 1;
// cin >> T;
while (T--)
{
solve();
}
return 0;
} | 这里是题目描述：# [JSOI2008] 星球大战
## 题目描述
很久以前，在一个遥远的星系，一个黑暗的帝国靠着它的超级武器统治着整个星系。
某一天，凭着一个偶然的机遇，一支反抗军摧毁了帝国的超级武器，并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直接或间接地连接。
但好景不长，很快帝国又重新造出了他的超级武器。凭借这超级武器的力量，帝国开始有计划地摧毁反抗军占领的星球。由于星球的不断被摧毁，两个星球之间的通讯通道也开始不可靠起来。
现在，反抗军首领交给你一个任务：给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序，以尽量快的速度求出每一次打击之后反抗军占据的星球的连通块的个数。（如果两个星球可以通过现存的以太通道直接或间接地连通，则这两个星球在同一个连通块中）。
## 输入格式
输入文件第一行包含两个整数，$n,m$，分别表示星球的数目和以太隧道的数目。星球用 $0 \sim n-1$ 的整数编号。
接下来的 $m$ 行，每行包括两个整数 $x,y$，表示星球 $x$ 和星球 $y$ 之间有 “以太” 隧道，可以直接通讯。
接下来的一行为一个整数 $k$ ，表示将遭受攻击的星球的数目。
接下来的 $k$ 行，每行有一个整数，按照顺序列出了帝国军的攻击目标。这 $k$ 个数互不相同，且都在 $0$ 到 $n-1$ 的范围内。
## 输出格式
第一行是开始时星球的连通块个数。接下来的 $k$ 行，每行一个整数，表示经过该次打击后现存星球的连通块个数。
## 样例 #1
### 样例输入 #1
```
8 13
0 1
1 6
6 5
5 0
0 6
1 2
2 3
3 4
4 5
7 1
7 2
7 6
3 6
5
1
6
3
5
7
```
### 样例输出 #1
```
1
1
1
2
3
3
```
## 提示
【数据范围】
对于 $100\%$ 的数据，$1\le m \le 2\times 10^5$，$1\le n \le 2m$，$x \neq y$。
[JSOI2008] 下面是题目解析和做法：第一份题解：
这道题看似很长其实也不是十分的难
如果我们去正这摧毁 想想都有点困难
要不 我们使用逆向思维？
没错 这道题就把摧毁转换成修建~~（和平就是好）~~
利用并查集判断联通就好了
```cpp
#include<iostream>
#include<cstdio>
#define f(i,a,b) for(register int i=a;i<=b;i++)
#define fd(i,a,b) for(register int i=a;i>=b;i--)
using namespace std;
int k,n,m,head[400002],tot,broken[400002],ans[400003];
int father[400003];
struct Node
{
int next,node,from;
}h[400002];
inline void Add_Node(int u,int v)
{
h[++tot].from=u;
h[tot].next=head[u];
head[u]=tot;
h[tot].node=v;
}
bool Broken[400001];
inline int Get_father(int x)
{
if(father[x]==x) return x;
return father[x]=Get_father(father[x]);
//你爸爸的爸爸就是你的爸爸——反查理马特——并查集
}
inline void hb(int u,int v)
{
u=Get_father(u),v=Get_father(v);
if(u!=v) father[v]=u;
}
int main()
{
ios::sync_with_stdio(false);
cin>>n>>m;
f(i,0,n)
father[i]=i,head[i]=-1;//并查集初始化
f(i,1,m)
{
int x,y;
cin>>x>>y;
Add_Node(x,y);//储存图
Add_Node(y,x);//由于无向图存两遍
}
cin>>k;
f(i,1,k)
{
cin>>broken[i];
Broken[broken[i]]=1;//标记砸坏了
}
int total=n-k;//初始化为所有点都是单独存在的
f(i,1,2*m)//有2*m个边
if(!Broken[h[i].from] && !Broken[h[i].node] && Get_father(h[i].from)!=Get_father(h[i].node))
{//要是起点和终点都没砸坏 而且他们并没有联通
total--;//连一条边 减一个联通体
hb(h[i].from,h[i].node);
}
ans[k+1]=total;//当前就是最后一次破坏后的个数
fd(i,k,1)
{
//total=0 //这里不需要初始化 需要从上一次的废墟上修建
total++;//修复一个点 联通体+1
Broken[broken[i]]=0;//修复
for(int j=head[broken[i]];j!=-1;j=h[j].next)//枚举每一个子点
{
if(!Broken[h[j].node] && Get_father(broken[i])!=Get_father(h[j].node))
{
total--;//连一边减一个联通块
hb(broken[i],h[j].node);//合并这两个点
}
}
ans[i]=total;
}
f(i,1,k+1) cout<<ans[i]<<endl;
return 0;
}
```
第二个题解：
题目标签：并 查 集 | #include <bits/stdc++.h>
using namespace std;
#define itn int
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<ll, ll> PLL;
#define x first
#define y second
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define lep(i, a, b) for (int i = (a); i >= (b); i--)
#define sci(x) cin >> (x)
#define pri(x) cout << (x) << " ";
#define prl(x) cout << (x) << '\n';
#define pli(x) cout << (x) << " ";
#define pll(x) cout << (x) << '\n';
#define mem(a, x) memset(a, x, sizeof a)
#define mep(a, x) memcpy(a, x, sizeof x)
#define yes cout << "YES" << '\n';
#define no cout << "NO" << '\n';
#define ls u << 1
#define rs u << 1 | 1
// cout << "? " << << ' ';
// printf("case:%d %d\n", );
const int N = 1e6 + 10;
// const ll p = 1e9 + 7;
ll n, m, k;
ll b[N], f[N], p[N], a[N];
char s[N], t[N];
vector<int> e[N];
PLL tr[N];
int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }
void solve()
{
cin >> n >> m;
ll res = 0;
rep(i, 0, n - 1) p[i] = i;
rep(i, 1, m)
{
ll x, y;
cin >> x >> y;
e[x].push_back(y), e[y].push_back(x);
tr[i] = {x, y};
}
sci(k);
rep(i, 1, k) sci(a[i]), b[a[i]] = 1;
rep(i, 1, m) if (!b[tr[i].x] && !b[tr[i].y]) p[find(tr[i].x)] = find(tr[i].y);
rep(i, 0, n - 1) if (!b[i] && i == find(i))++ res; // pll(res)
f[k + 1] = res;
lep(i, k, 1)
{
++res;
for (auto j : e[a[i]])
{
if (b[j] == 1)
continue;
if (find(j) != find(a[i]))
--res;
p[find(j)] = find(a[i]);
}
f[i] = res;
b[a[i]] = 1;
}
rep(i, 1, k + 1) pll(f[i])
}
signed main()
{
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int T;
T = 1;
// cin >> T;
while (T--)
{
solve();
}
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
int n, m, k;
int fa[N], ar[N];
bool st[N];
vector<int> q[N];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void solve()
{
for (int i = 0; i < N; i++)
fa[i] = i;
cin >> n >> m;
for (int i = 1, a, b; i <= m; i++)
{
cin >> a >> b;
q[a].push_back(b);
q[b].push_back(a);
}
cin >> k;
for (int i = 1; i <= k; i++)
{
cin >> ar[i];
st[ar[i]] = true;
}
int res = n - k;
for (int i = 0; i < n; i++)
{
if (st[i])
continue;
for (auto j : q[i])
{
if (st[j])
continue;
int x = find(i), y = find(j);
if (x != y)
{
fa[y] = x;
res--;
}
}
}
stack<int> p;
for (int i = k; i >= 1; i--)
{
st[ar[i]] = false;
p.push(res);
res++;
for (auto j : q[ar[i]])
{
if (st[j])
continue;
int x = find(ar[i]), y = find(j);
if (x != y)
{
fa[y] = x;
res--;
}
}
}
p.push(res);
while (!p.empty())
{
cout << p.top() << "\n";
p.pop();
}
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
} | 这里是题目描述：# [JSOI2008] 星球大战
## 题目描述
很久以前，在一个遥远的星系，一个黑暗的帝国靠着它的超级武器统治着整个星系。
某一天，凭着一个偶然的机遇，一支反抗军摧毁了帝国的超级武器，并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直接或间接地连接。
但好景不长，很快帝国又重新造出了他的超级武器。凭借这超级武器的力量，帝国开始有计划地摧毁反抗军占领的星球。由于星球的不断被摧毁，两个星球之间的通讯通道也开始不可靠起来。
现在，反抗军首领交给你一个任务：给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序，以尽量快的速度求出每一次打击之后反抗军占据的星球的连通块的个数。（如果两个星球可以通过现存的以太通道直接或间接地连通，则这两个星球在同一个连通块中）。
## 输入格式
输入文件第一行包含两个整数，$n,m$，分别表示星球的数目和以太隧道的数目。星球用 $0 \sim n-1$ 的整数编号。
接下来的 $m$ 行，每行包括两个整数 $x,y$，表示星球 $x$ 和星球 $y$ 之间有 “以太” 隧道，可以直接通讯。
接下来的一行为一个整数 $k$ ，表示将遭受攻击的星球的数目。
接下来的 $k$ 行，每行有一个整数，按照顺序列出了帝国军的攻击目标。这 $k$ 个数互不相同，且都在 $0$ 到 $n-1$ 的范围内。
## 输出格式
第一行是开始时星球的连通块个数。接下来的 $k$ 行，每行一个整数，表示经过该次打击后现存星球的连通块个数。
## 样例 #1
### 样例输入 #1
```
8 13
0 1
1 6
6 5
5 0
0 6
1 2
2 3
3 4
4 5
7 1
7 2
7 6
3 6
5
1
6
3
5
7
```
### 样例输出 #1
```
1
1
1
2
3
3
```
## 提示
【数据范围】
对于 $100\%$ 的数据，$1\le m \le 2\times 10^5$，$1\le n \le 2m$，$x \neq y$。
[JSOI2008] 下面是题目解析和做法：第一份题解：
这道题看似很长其实也不是十分的难
如果我们去正这摧毁 想想都有点困难
要不 我们使用逆向思维？
没错 这道题就把摧毁转换成修建~~（和平就是好）~~
利用并查集判断联通就好了
```cpp
#include<iostream>
#include<cstdio>
#define f(i,a,b) for(register int i=a;i<=b;i++)
#define fd(i,a,b) for(register int i=a;i>=b;i--)
using namespace std;
int k,n,m,head[400002],tot,broken[400002],ans[400003];
int father[400003];
struct Node
{
int next,node,from;
}h[400002];
inline void Add_Node(int u,int v)
{
h[++tot].from=u;
h[tot].next=head[u];
head[u]=tot;
h[tot].node=v;
}
bool Broken[400001];
inline int Get_father(int x)
{
if(father[x]==x) return x;
return father[x]=Get_father(father[x]);
//你爸爸的爸爸就是你的爸爸——反查理马特——并查集
}
inline void hb(int u,int v)
{
u=Get_father(u),v=Get_father(v);
if(u!=v) father[v]=u;
}
int main()
{
ios::sync_with_stdio(false);
cin>>n>>m;
f(i,0,n)
father[i]=i,head[i]=-1;//并查集初始化
f(i,1,m)
{
int x,y;
cin>>x>>y;
Add_Node(x,y);//储存图
Add_Node(y,x);//由于无向图存两遍
}
cin>>k;
f(i,1,k)
{
cin>>broken[i];
Broken[broken[i]]=1;//标记砸坏了
}
int total=n-k;//初始化为所有点都是单独存在的
f(i,1,2*m)//有2*m个边
if(!Broken[h[i].from] && !Broken[h[i].node] && Get_father(h[i].from)!=Get_father(h[i].node))
{//要是起点和终点都没砸坏 而且他们并没有联通
total--;//连一条边 减一个联通体
hb(h[i].from,h[i].node);
}
ans[k+1]=total;//当前就是最后一次破坏后的个数
fd(i,k,1)
{
//total=0 //这里不需要初始化 需要从上一次的废墟上修建
total++;//修复一个点 联通体+1
Broken[broken[i]]=0;//修复
for(int j=head[broken[i]];j!=-1;j=h[j].next)//枚举每一个子点
{
if(!Broken[h[j].node] && Get_father(broken[i])!=Get_father(h[j].node))
{
total--;//连一边减一个联通块
hb(broken[i],h[j].node);//合并这两个点
}
}
ans[i]=total;
}
f(i,1,k+1) cout<<ans[i]<<endl;
return 0;
}
```
第二个题解：
题目标签：并 查 集 | #include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
int n, m, k;
int fa[N], ar[N];
bool st[N];
vector<int> q[N];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void solve()
{
for (int i = 0; i < N; i++)
fa[i] = i;
cin >> n >> m;
for (int i = 1, a, b; i <= m; i++)
{
cin >> a >> b;
q[a].push_back(b);
q[b].push_back(a);
}
stack<int> p;
cin >> k;
for (int i = 1; i <= k; i++)
{
cin >> ar[i];
st[ar[i]] = true;
}
int res = 0;
for (int i = 0; i < n; i++)
{
if (!st[i])
res++;
}
for (int i = 0; i < n; i++)
{
if (st[i])
continue;
for (auto j : q[i])
{
if (st[j])
continue;
int x = find(i), y = find(j);
if (x != y)
{
fa[y] = x;
res--;
}
}
}
for (int i = k; i >= 1; i--)
{
st[ar[k]] = false;
p.push(res);
res++;
for (auto j : q[ar[i]])
{
if (st[j])
continue;
int x = find(ar[i]), y = find(j);
if (x != y)
{
fa[y] = x;
res--;
}
}
}
p.push(res);
while (!p.empty())
{
cout << p.top() << "\n";
p.pop();
}
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 400010;
int n, m, k, p[N], c[N], ans[N];
bool st[N];
int h[N], e[N], ne[N], idx;
struct Edge
{
int a, b;
} edge[N >> 1];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
int find(int x)
{
if (x != p[x])
p[x] = find(p[x]);
return p[x];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
for (int i = 0; i < m; i++)
{
scanf("%d%d", &edge[i].a, &edge[i].b);
add(edge[i].a, edge[i].b), add(edge[i].b, edge[i].a);
}
for (int i = 0; i < n; i++)
p[i] = i;
scanf("%d", &k);
for (int i = 0; i < k; i++)
{
scanf("%d", &c[i]);
st[c[i]] = true;
}
int cnt = n - k;
for (int i = 0; i < m; i++)
{
if (st[edge[i].a] == false && st[edge[i].b] == false)
{
if (find(edge[i].a) != find(edge[i].b))
{
cnt--;
p[find(edge[i].a)] = find(edge[i].b);
}
}
}
ans[k] = cnt;
for (int i = k - 1; i >= 0; i--)
{
cnt++;
st[c[i]] = false;
for (int j = h[c[i]]; ~j; j = ne[j])
{
if (st[e[j]] == false)
{
if (find(e[j]) != find(c[i]))
{
cnt--;
p[find(e[j])] = find(c[i]);
}
}
}
ans[i] = cnt;
}
for (int i = 0; i <= k; i++)
printf("%d\n", ans[i]);
return 0;
} | 这里是题目描述：# [JSOI2008] 星球大战
## 题目描述
很久以前，在一个遥远的星系，一个黑暗的帝国靠着它的超级武器统治着整个星系。
某一天，凭着一个偶然的机遇，一支反抗军摧毁了帝国的超级武器，并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直接或间接地连接。
但好景不长，很快帝国又重新造出了他的超级武器。凭借这超级武器的力量，帝国开始有计划地摧毁反抗军占领的星球。由于星球的不断被摧毁，两个星球之间的通讯通道也开始不可靠起来。
现在，反抗军首领交给你一个任务：给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序，以尽量快的速度求出每一次打击之后反抗军占据的星球的连通块的个数。（如果两个星球可以通过现存的以太通道直接或间接地连通，则这两个星球在同一个连通块中）。
## 输入格式
输入文件第一行包含两个整数，$n,m$，分别表示星球的数目和以太隧道的数目。星球用 $0 \sim n-1$ 的整数编号。
接下来的 $m$ 行，每行包括两个整数 $x,y$，表示星球 $x$ 和星球 $y$ 之间有 “以太” 隧道，可以直接通讯。
接下来的一行为一个整数 $k$ ，表示将遭受攻击的星球的数目。
接下来的 $k$ 行，每行有一个整数，按照顺序列出了帝国军的攻击目标。这 $k$ 个数互不相同，且都在 $0$ 到 $n-1$ 的范围内。
## 输出格式
第一行是开始时星球的连通块个数。接下来的 $k$ 行，每行一个整数，表示经过该次打击后现存星球的连通块个数。
## 样例 #1
### 样例输入 #1
```
8 13
0 1
1 6
6 5
5 0
0 6
1 2
2 3
3 4
4 5
7 1
7 2
7 6
3 6
5
1
6
3
5
7
```
### 样例输出 #1
```
1
1
1
2
3
3
```
## 提示
【数据范围】
对于 $100\%$ 的数据，$1\le m \le 2\times 10^5$，$1\le n \le 2m$，$x \neq y$。
[JSOI2008] 下面是题目解析和做法：第一份题解：
这道题看似很长其实也不是十分的难
如果我们去正这摧毁 想想都有点困难
要不 我们使用逆向思维？
没错 这道题就把摧毁转换成修建~~（和平就是好）~~
利用并查集判断联通就好了
```cpp
#include<iostream>
#include<cstdio>
#define f(i,a,b) for(register int i=a;i<=b;i++)
#define fd(i,a,b) for(register int i=a;i>=b;i--)
using namespace std;
int k,n,m,head[400002],tot,broken[400002],ans[400003];
int father[400003];
struct Node
{
int next,node,from;
}h[400002];
inline void Add_Node(int u,int v)
{
h[++tot].from=u;
h[tot].next=head[u];
head[u]=tot;
h[tot].node=v;
}
bool Broken[400001];
inline int Get_father(int x)
{
if(father[x]==x) return x;
return father[x]=Get_father(father[x]);
//你爸爸的爸爸就是你的爸爸——反查理马特——并查集
}
inline void hb(int u,int v)
{
u=Get_father(u),v=Get_father(v);
if(u!=v) father[v]=u;
}
int main()
{
ios::sync_with_stdio(false);
cin>>n>>m;
f(i,0,n)
father[i]=i,head[i]=-1;//并查集初始化
f(i,1,m)
{
int x,y;
cin>>x>>y;
Add_Node(x,y);//储存图
Add_Node(y,x);//由于无向图存两遍
}
cin>>k;
f(i,1,k)
{
cin>>broken[i];
Broken[broken[i]]=1;//标记砸坏了
}
int total=n-k;//初始化为所有点都是单独存在的
f(i,1,2*m)//有2*m个边
if(!Broken[h[i].from] && !Broken[h[i].node] && Get_father(h[i].from)!=Get_father(h[i].node))
{//要是起点和终点都没砸坏 而且他们并没有联通
total--;//连一条边 减一个联通体
hb(h[i].from,h[i].node);
}
ans[k+1]=total;//当前就是最后一次破坏后的个数
fd(i,k,1)
{
//total=0 //这里不需要初始化 需要从上一次的废墟上修建
total++;//修复一个点 联通体+1
Broken[broken[i]]=0;//修复
for(int j=head[broken[i]];j!=-1;j=h[j].next)//枚举每一个子点
{
if(!Broken[h[j].node] && Get_father(broken[i])!=Get_father(h[j].node))
{
total--;//连一边减一个联通块
hb(broken[i],h[j].node);//合并这两个点
}
}
ans[i]=total;
}
f(i,1,k+1) cout<<ans[i]<<endl;
return 0;
}
```
第二个题解：
题目标签：并 查 集 | #include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 400010;
int n, m, k, p[N], c[N], ans[N];
bool st[N];
int h[N], e[N], ne[N], idx;
struct Edge
{
int a, b;
} edge[N >> 1];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
int find(int x)
{
if (x != p[x])
p[x] = find(p[x]);
return p[x];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
for (int i = 0; i < m; i++)
{
scanf("%d%d", &edge[i].a, &edge[i].b);
add(edge[i].a, edge[i].b), add(edge[i].b, edge[i].a);
}
for (int i = 0; i < n; i++)
p[i] = i;
scanf("%d", &k);
for (int i = 0; i < k; i++)
{
scanf("%d", &c[i]);
st[c[i]] = true;
}
int cnt = n - k;
for (int i = 0; i < m; i++)
{
if (st[edge[i].a] == false && st[edge[i].b] == false)
{
if (find(edge[i].a) != find(edge[i].b))
{
cnt--;
p[find(edge[i].a)] = find(edge[i].b);
}
}
}
ans[k] = cnt;
for (int i = k - 1; i >= 0; i--)
{
cnt++;
st[c[i]] = false;
for (int j = h[c[i]]; ~j; j = ne[i])
{
if (st[e[j]] == false)
{
if (find(e[j]) != find(c[i]))
{
cnt--;
p[find(e[j])] = find(c[i]);
}
}
}
ans[i] = cnt;
}
for (int i = 0; i <= k; i++)
printf("%d\n", ans[i]);
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using ll = long long;
#define endl '\n'
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define pii pair<int, int>
#define pll pair<long long, long long>
#define all(x) x.begin(), x.end()
using namespace std;
const int N = 2e5 + 20;
int n, m, k;
pii edges[N];
int p[2 * N], pa[2 * N], fl[2 * N], ans[2 * N];
vector<int> adj[2 * N];
int findpa(int x)
{
if (x != pa[x])
pa[x] = findpa(pa[x]);
return pa[x];
return x == pa[x] ? x : pa[x] = findpa(pa[x]);
}
void unite(int x, int y)
{
pa[findpa(x)] = findpa(y);
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
rep(i, 1, n + 1)
{
pa[i] = i;
}
rep(i, 1, m + 1)
{
cin >> edges[i].first >> edges[i].second;
edges[i].first++;
edges[i].second++;
if (edges[i].first > edges[i].second)
swap(edges[i].first, edges[i].second);
adj[edges[i].first].push_back(edges[i].second);
adj[edges[i].second].push_back(edges[i].first);
}
cin >> k;
rep(i, 1, k + 1)
{
cin >> p[i];
p[i]++;
fl[p[i]] = 1;
}
int cur = n - k;
rep(i, 1, m + 1)
{
int u = edges[i].first, v = edges[i].second;
if (!fl[u] && !fl[v] && findpa(u) != findpa(v))
{
unite(u, v);
cur--;
}
}
ans[k + 1] = cur;
per(i, k, 1)
{
cur++;
fl[p[i]] = 0;
for (int v : adj[p[i]])
{
if (!fl[v] && findpa(p[i]) != findpa(v))
{
unite(p[i], v);
cur--;
}
}
ans[i] = cur;
}
rep(i, 1, k + 2)
{
cout << ans[i] << "\n";
}
return 0;
} | 这里是题目描述：# [JSOI2008] 星球大战
## 题目描述
很久以前，在一个遥远的星系，一个黑暗的帝国靠着它的超级武器统治着整个星系。
某一天，凭着一个偶然的机遇，一支反抗军摧毁了帝国的超级武器，并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直接或间接地连接。
但好景不长，很快帝国又重新造出了他的超级武器。凭借这超级武器的力量，帝国开始有计划地摧毁反抗军占领的星球。由于星球的不断被摧毁，两个星球之间的通讯通道也开始不可靠起来。
现在，反抗军首领交给你一个任务：给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序，以尽量快的速度求出每一次打击之后反抗军占据的星球的连通块的个数。（如果两个星球可以通过现存的以太通道直接或间接地连通，则这两个星球在同一个连通块中）。
## 输入格式
输入文件第一行包含两个整数，$n,m$，分别表示星球的数目和以太隧道的数目。星球用 $0 \sim n-1$ 的整数编号。
接下来的 $m$ 行，每行包括两个整数 $x,y$，表示星球 $x$ 和星球 $y$ 之间有 “以太” 隧道，可以直接通讯。
接下来的一行为一个整数 $k$ ，表示将遭受攻击的星球的数目。
接下来的 $k$ 行，每行有一个整数，按照顺序列出了帝国军的攻击目标。这 $k$ 个数互不相同，且都在 $0$ 到 $n-1$ 的范围内。
## 输出格式
第一行是开始时星球的连通块个数。接下来的 $k$ 行，每行一个整数，表示经过该次打击后现存星球的连通块个数。
## 样例 #1
### 样例输入 #1
```
8 13
0 1
1 6
6 5
5 0
0 6
1 2
2 3
3 4
4 5
7 1
7 2
7 6
3 6
5
1
6
3
5
7
```
### 样例输出 #1
```
1
1
1
2
3
3
```
## 提示
【数据范围】
对于 $100\%$ 的数据，$1\le m \le 2\times 10^5$，$1\le n \le 2m$，$x \neq y$。
[JSOI2008] 下面是题目解析和做法：第一份题解：
这道题看似很长其实也不是十分的难
如果我们去正这摧毁 想想都有点困难
要不 我们使用逆向思维？
没错 这道题就把摧毁转换成修建~~（和平就是好）~~
利用并查集判断联通就好了
```cpp
#include<iostream>
#include<cstdio>
#define f(i,a,b) for(register int i=a;i<=b;i++)
#define fd(i,a,b) for(register int i=a;i>=b;i--)
using namespace std;
int k,n,m,head[400002],tot,broken[400002],ans[400003];
int father[400003];
struct Node
{
int next,node,from;
}h[400002];
inline void Add_Node(int u,int v)
{
h[++tot].from=u;
h[tot].next=head[u];
head[u]=tot;
h[tot].node=v;
}
bool Broken[400001];
inline int Get_father(int x)
{
if(father[x]==x) return x;
return father[x]=Get_father(father[x]);
//你爸爸的爸爸就是你的爸爸——反查理马特——并查集
}
inline void hb(int u,int v)
{
u=Get_father(u),v=Get_father(v);
if(u!=v) father[v]=u;
}
int main()
{
ios::sync_with_stdio(false);
cin>>n>>m;
f(i,0,n)
father[i]=i,head[i]=-1;//并查集初始化
f(i,1,m)
{
int x,y;
cin>>x>>y;
Add_Node(x,y);//储存图
Add_Node(y,x);//由于无向图存两遍
}
cin>>k;
f(i,1,k)
{
cin>>broken[i];
Broken[broken[i]]=1;//标记砸坏了
}
int total=n-k;//初始化为所有点都是单独存在的
f(i,1,2*m)//有2*m个边
if(!Broken[h[i].from] && !Broken[h[i].node] && Get_father(h[i].from)!=Get_father(h[i].node))
{//要是起点和终点都没砸坏 而且他们并没有联通
total--;//连一条边 减一个联通体
hb(h[i].from,h[i].node);
}
ans[k+1]=total;//当前就是最后一次破坏后的个数
fd(i,k,1)
{
//total=0 //这里不需要初始化 需要从上一次的废墟上修建
total++;//修复一个点 联通体+1
Broken[broken[i]]=0;//修复
for(int j=head[broken[i]];j!=-1;j=h[j].next)//枚举每一个子点
{
if(!Broken[h[j].node] && Get_father(broken[i])!=Get_father(h[j].node))
{
total--;//连一边减一个联通块
hb(broken[i],h[j].node);//合并这两个点
}
}
ans[i]=total;
}
f(i,1,k+1) cout<<ans[i]<<endl;
return 0;
}
```
第二个题解：
题目标签：并 查 集 | #include <bits/stdc++.h>
using ll = long long;
#define endl '\n'
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define pii pair<int, int>
#define pll pair<long long, long long>
#define all(x) x.begin(), x.end()
using namespace std;
const int N = 2e5 + 20;
int n, m, k;
pii edges[N];
int p[2 * N], pa[2 * N], fl[2 * N], ans[2 * N];
vector<int> adj[2 * N];
int findpa(int x)
{
return x == pa[x] ? x : pa[x] = findpa(pa[x]);
}
void unite(int x, int y)
{
if (x > y)
swap(x, y);
if (findpa(x) != findpa(y))
{
pa[x] = findpa(y);
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
rep(i, 1, n + 1)
{
pa[i] = i;
}
rep(i, 1, m + 1)
{
cin >> edges[i].first >> edges[i].second;
edges[i].first++;
edges[i].second++;
adj[edges[i].first].push_back(edges[i].second);
adj[edges[i].second].push_back(edges[i].first);
}
cin >> k;
rep(i, 1, k + 1)
{
cin >> p[i];
p[i]++;
fl[p[i]] = 1;
}
int cur = n - k;
rep(i, 1, m + 1)
{
if (!fl[edges[i].first] && !fl[edges[i].second])
{
if (findpa(edges[i].first) != findpa(edges[i].second))
{
unite(edges[i].first, edges[i].second);
cur--;
}
}
}
ans[k + 1] = cur;
per(i, k, 1)
{
cur++;
fl[p[i]] = 0;
for (int v : adj[p[i]])
{
if (!fl[v] && findpa(p[i]) != findpa(v))
{
unite(p[i], v);
cur--;
}
}
ans[i] = max(1, cur);
}
rep(i, 1, k + 2)
{
cout << ans[i] << "\n";
}
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int f[400005], head[400005], h[400005], ans[400005], cnt = 0;
bool e[400005];
int find(int x)
{
if (x != f[x])
f[x] = find(f[x]);
return f[x];
}
struct edge
{
int from;
int to;
int next;
} a[400005];
void insert(int u, int v)
{
a[cnt].from = u;
a[cnt].next = head[u];
a[cnt].to = v;
head[u] = cnt;
cnt++;
}
int main()
{
int n, m, k, x, y, tot, i, u;
cin >> n >> m;
for (i = 0; i < n; ++i)
{
f[i] = i;
head[i] = -1;
}
for (i = 0; i < m; ++i)
{
cin >> x >> y;
insert(x, y);
insert(y, x);
}
cin >> k;
tot = n - k;
for (i = 1; i <= k; i++)
{
cin >> x;
e[x] = true;
h[i] = x;
}
for (i = 0; i < 2 * m; i++)
{
if (e[a[i].from] == false && e[a[i].to] == false)
{
if (find(a[i].from) != find(a[i].to))
{
tot--;
f[find(a[i].from)] = f[find(a[i].to)];
}
}
}
ans[k + 1] = tot;
for (int t = k; t >= 1; t--)
{
u = h[t];
tot++;
e[u] = false;
for (i = head[u]; i != -1; i = a[i].next)
{
if (e[a[i].to] == false && f[find(u)] != f[find(a[i].to)])
{
tot--;
f[find(a[i].to)] = f[find(u)];
}
}
ans[t] = tot;
}
for (i = 1; i <= k + 1; ++i)
{
cout << ans[i] << endl;
}
return 0;
} | 这里是题目描述：# [JSOI2008] 星球大战
## 题目描述
很久以前，在一个遥远的星系，一个黑暗的帝国靠着它的超级武器统治着整个星系。
某一天，凭着一个偶然的机遇，一支反抗军摧毁了帝国的超级武器，并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直接或间接地连接。
但好景不长，很快帝国又重新造出了他的超级武器。凭借这超级武器的力量，帝国开始有计划地摧毁反抗军占领的星球。由于星球的不断被摧毁，两个星球之间的通讯通道也开始不可靠起来。
现在，反抗军首领交给你一个任务：给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序，以尽量快的速度求出每一次打击之后反抗军占据的星球的连通块的个数。（如果两个星球可以通过现存的以太通道直接或间接地连通，则这两个星球在同一个连通块中）。
## 输入格式
输入文件第一行包含两个整数，$n,m$，分别表示星球的数目和以太隧道的数目。星球用 $0 \sim n-1$ 的整数编号。
接下来的 $m$ 行，每行包括两个整数 $x,y$，表示星球 $x$ 和星球 $y$ 之间有 “以太” 隧道，可以直接通讯。
接下来的一行为一个整数 $k$ ，表示将遭受攻击的星球的数目。
接下来的 $k$ 行，每行有一个整数，按照顺序列出了帝国军的攻击目标。这 $k$ 个数互不相同，且都在 $0$ 到 $n-1$ 的范围内。
## 输出格式
第一行是开始时星球的连通块个数。接下来的 $k$ 行，每行一个整数，表示经过该次打击后现存星球的连通块个数。
## 样例 #1
### 样例输入 #1
```
8 13
0 1
1 6
6 5
5 0
0 6
1 2
2 3
3 4
4 5
7 1
7 2
7 6
3 6
5
1
6
3
5
7
```
### 样例输出 #1
```
1
1
1
2
3
3
```
## 提示
【数据范围】
对于 $100\%$ 的数据，$1\le m \le 2\times 10^5$，$1\le n \le 2m$，$x \neq y$。
[JSOI2008] 下面是题目解析和做法：第一份题解：
这道题看似很长其实也不是十分的难
如果我们去正这摧毁 想想都有点困难
要不 我们使用逆向思维？
没错 这道题就把摧毁转换成修建~~（和平就是好）~~
利用并查集判断联通就好了
```cpp
#include<iostream>
#include<cstdio>
#define f(i,a,b) for(register int i=a;i<=b;i++)
#define fd(i,a,b) for(register int i=a;i>=b;i--)
using namespace std;
int k,n,m,head[400002],tot,broken[400002],ans[400003];
int father[400003];
struct Node
{
int next,node,from;
}h[400002];
inline void Add_Node(int u,int v)
{
h[++tot].from=u;
h[tot].next=head[u];
head[u]=tot;
h[tot].node=v;
}
bool Broken[400001];
inline int Get_father(int x)
{
if(father[x]==x) return x;
return father[x]=Get_father(father[x]);
//你爸爸的爸爸就是你的爸爸——反查理马特——并查集
}
inline void hb(int u,int v)
{
u=Get_father(u),v=Get_father(v);
if(u!=v) father[v]=u;
}
int main()
{
ios::sync_with_stdio(false);
cin>>n>>m;
f(i,0,n)
father[i]=i,head[i]=-1;//并查集初始化
f(i,1,m)
{
int x,y;
cin>>x>>y;
Add_Node(x,y);//储存图
Add_Node(y,x);//由于无向图存两遍
}
cin>>k;
f(i,1,k)
{
cin>>broken[i];
Broken[broken[i]]=1;//标记砸坏了
}
int total=n-k;//初始化为所有点都是单独存在的
f(i,1,2*m)//有2*m个边
if(!Broken[h[i].from] && !Broken[h[i].node] && Get_father(h[i].from)!=Get_father(h[i].node))
{//要是起点和终点都没砸坏 而且他们并没有联通
total--;//连一条边 减一个联通体
hb(h[i].from,h[i].node);
}
ans[k+1]=total;//当前就是最后一次破坏后的个数
fd(i,k,1)
{
//total=0 //这里不需要初始化 需要从上一次的废墟上修建
total++;//修复一个点 联通体+1
Broken[broken[i]]=0;//修复
for(int j=head[broken[i]];j!=-1;j=h[j].next)//枚举每一个子点
{
if(!Broken[h[j].node] && Get_father(broken[i])!=Get_father(h[j].node))
{
total--;//连一边减一个联通块
hb(broken[i],h[j].node);//合并这两个点
}
}
ans[i]=total;
}
f(i,1,k+1) cout<<ans[i]<<endl;
return 0;
}
```
第二个题解：
题目标签：并 查 集 | #include <iostream>
#include <vector>
using namespace std;
#define int long long
int f[400005], ans[400005], a[400005], b[400005], c;
bool vis[400005];
int find(int x)
{
if (f[x] == x)
{
return x;
}
return f[x] = find(f[x]);
}
vector<int> e[400005];
struct node
{
int u, v;
} g[400005];
int sum;
signed main()
{
int n, m, x, y, k;
cin >> n >> m;
for (int i = 1; i <= n; i++)
{
f[i] = i;
}
for (int i = 1; i <= m; i++)
{
cin >> x >> y;
e[x].push_back(y);
e[y].push_back(x);
g[++sum].u = x;
g[sum].v = y;
g[++sum].u = y;
g[sum].v = x;
}
cin >> k;
c = n - k;
for (int i = 1; i <= k; i++)
{
cin >> x;
vis[x] = true;
a[i] = x;
}
for (int i = 1; i <= 2 * m; i++)
{
if (vis[g[i].u] == false && vis[g[i].v] == false)
{
x = g[i].u, y = g[i].v;
if (find(x) != find(y))
{
c--;
f[find(x)] == f[find(y)];
}
}
}
ans[k + 1] = c;
for (int i = k; i >= 1; i--)
{
int u = a[i];
c++;
vis[u] = false;
for (auto v : e[u])
{
if (vis[v] == false && f[find(u)] != f[find(v)])
{
c--;
f[find(v)] = f[find(u)];
}
}
ans[i] = c;
}
for (int i = 1; i <= k + 1; i++)
{
cout << ans[i] << endl;
}
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e6 + 50;
vector<int> ans; // 存答案
vector<int> a[N]; // 存图
int h[N]; // 存要摧毁(修复)的星球
int fa[N]; // 父节点
int vis[N]; // 标记是否是要被摧毁(修复)的星球
int find(int x)
{
if (x != fa[x])
fa[x] = find(fa[x]);
return fa[x];
}
void add(int x, int y)
{
int fx = find(x);
int fy = find(y);
if (x != y)
fa[fx] = fy;
}
int main()
{
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
fa[i] = i;
for (int i = 1; i <= m; i++)
{
int u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
int k;
cin >> k;
for (int i = 1; i <= k; i++)
{
cin >> h[i];
vis[h[i]] = 1;
}
for (int i = 0; i < n; i++)
{
for (auto x : a[i])
{
if (vis[x] || vis[i])
continue;
add(x, i);
}
}
int cnt = 0; // 未修复之前连通块的个数
for (int i = 0; i < n; i++)
{
if (!vis[i] && fa[i] == i)
cnt++; // 修复前连通块的个数
}
ans.push_back(cnt);
for (int i = k; i >= 1; i--)
{
int x = h[i];
cnt++; // 先把x看成一个独立的连通块
vis[x] = 0; // 被修复
for (auto u : a[x])
{
if (!vis[u] && find(x) != find(u))
{
add(u, x);
cnt--;
}
}
ans.push_back(cnt);
}
reverse(ans.begin(), ans.end());
for (auto c : ans)
cout << c << '\n';
return 0;
} | 这里是题目描述：# [JSOI2008] 星球大战
## 题目描述
很久以前，在一个遥远的星系，一个黑暗的帝国靠着它的超级武器统治着整个星系。
某一天，凭着一个偶然的机遇，一支反抗军摧毁了帝国的超级武器，并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直接或间接地连接。
但好景不长，很快帝国又重新造出了他的超级武器。凭借这超级武器的力量，帝国开始有计划地摧毁反抗军占领的星球。由于星球的不断被摧毁，两个星球之间的通讯通道也开始不可靠起来。
现在，反抗军首领交给你一个任务：给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序，以尽量快的速度求出每一次打击之后反抗军占据的星球的连通块的个数。（如果两个星球可以通过现存的以太通道直接或间接地连通，则这两个星球在同一个连通块中）。
## 输入格式
输入文件第一行包含两个整数，$n,m$，分别表示星球的数目和以太隧道的数目。星球用 $0 \sim n-1$ 的整数编号。
接下来的 $m$ 行，每行包括两个整数 $x,y$，表示星球 $x$ 和星球 $y$ 之间有 “以太” 隧道，可以直接通讯。
接下来的一行为一个整数 $k$ ，表示将遭受攻击的星球的数目。
接下来的 $k$ 行，每行有一个整数，按照顺序列出了帝国军的攻击目标。这 $k$ 个数互不相同，且都在 $0$ 到 $n-1$ 的范围内。
## 输出格式
第一行是开始时星球的连通块个数。接下来的 $k$ 行，每行一个整数，表示经过该次打击后现存星球的连通块个数。
## 样例 #1
### 样例输入 #1
```
8 13
0 1
1 6
6 5
5 0
0 6
1 2
2 3
3 4
4 5
7 1
7 2
7 6
3 6
5
1
6
3
5
7
```
### 样例输出 #1
```
1
1
1
2
3
3
```
## 提示
【数据范围】
对于 $100\%$ 的数据，$1\le m \le 2\times 10^5$，$1\le n \le 2m$，$x \neq y$。
[JSOI2008] 下面是题目解析和做法：第一份题解：
这道题看似很长其实也不是十分的难
如果我们去正这摧毁 想想都有点困难
要不 我们使用逆向思维？
没错 这道题就把摧毁转换成修建~~（和平就是好）~~
利用并查集判断联通就好了
```cpp
#include<iostream>
#include<cstdio>
#define f(i,a,b) for(register int i=a;i<=b;i++)
#define fd(i,a,b) for(register int i=a;i>=b;i--)
using namespace std;
int k,n,m,head[400002],tot,broken[400002],ans[400003];
int father[400003];
struct Node
{
int next,node,from;
}h[400002];
inline void Add_Node(int u,int v)
{
h[++tot].from=u;
h[tot].next=head[u];
head[u]=tot;
h[tot].node=v;
}
bool Broken[400001];
inline int Get_father(int x)
{
if(father[x]==x) return x;
return father[x]=Get_father(father[x]);
//你爸爸的爸爸就是你的爸爸——反查理马特——并查集
}
inline void hb(int u,int v)
{
u=Get_father(u),v=Get_father(v);
if(u!=v) father[v]=u;
}
int main()
{
ios::sync_with_stdio(false);
cin>>n>>m;
f(i,0,n)
father[i]=i,head[i]=-1;//并查集初始化
f(i,1,m)
{
int x,y;
cin>>x>>y;
Add_Node(x,y);//储存图
Add_Node(y,x);//由于无向图存两遍
}
cin>>k;
f(i,1,k)
{
cin>>broken[i];
Broken[broken[i]]=1;//标记砸坏了
}
int total=n-k;//初始化为所有点都是单独存在的
f(i,1,2*m)//有2*m个边
if(!Broken[h[i].from] && !Broken[h[i].node] && Get_father(h[i].from)!=Get_father(h[i].node))
{//要是起点和终点都没砸坏 而且他们并没有联通
total--;//连一条边 减一个联通体
hb(h[i].from,h[i].node);
}
ans[k+1]=total;//当前就是最后一次破坏后的个数
fd(i,k,1)
{
//total=0 //这里不需要初始化 需要从上一次的废墟上修建
total++;//修复一个点 联通体+1
Broken[broken[i]]=0;//修复
for(int j=head[broken[i]];j!=-1;j=h[j].next)//枚举每一个子点
{
if(!Broken[h[j].node] && Get_father(broken[i])!=Get_father(h[j].node))
{
total--;//连一边减一个联通块
hb(broken[i],h[j].node);//合并这两个点
}
}
ans[i]=total;
}
f(i,1,k+1) cout<<ans[i]<<endl;
return 0;
}
```
第二个题解：
题目标签：并 查 集 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 9;
int used[N], a[N], fa[N];
int n, m, k;
vector<int> v[N];
vector<int> ret;
void init()
{
for (int i = 0; i < n; ++i)
fa[i] = i;
}
int find(int x)
{
if (x == fa[x])
return x;
fa[x] = find(fa[x]);
return fa[x];
}
void merge(int i, int j)
{
int fi = find(i);
int fj = find(j);
if (i != j)
fa[fi] = fj;
}
int main()
{
cin >> n >> m;
init();
for (int i = 1; i <= m; ++i)
{
int tmp1, tmp2;
cin >> tmp1 >> tmp2;
v[tmp1].push_back(tmp2);
v[tmp2].push_back(tmp1);
}
cin >> k;
for (int i = 1; i <= k; ++i)
{
cin >> a[i];
used[a[i]] = 1;
}
for (int i = 0; i < n; ++i)
{
for (auto x : v[i])
{
if (used[x] || used[i])
continue;
/*if (find(x) != find(i))
ans--;*/
merge(x, i);
}
}
int ans = 0;
for (int i = 0; i < n; ++i)
{
if (!used[i] && fa[i] == i)
ans++;
}
ret.push_back(ans);
for (int i = k; i >= 1; --i)
{
ans++;
int x = a[i];
used[x] == 0;
for (auto e : v[x])
{
if (!used[e] && find(x) != find(e))
{
ans--;
merge(e, x);
}
}
ret.push_back(ans);
}
reverse(ret.begin(), ret.end());
for (auto c : ret)
cout << c << '\n';
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
int parent[N];
int b[N]; // 在i时刻被毁灭的星球为b[i];
bool g[N]; // 判断该点还是否在图中
int cnt[N]; // 判断该连通图是否计数
int ans[N];
void init(int n)
{
for (int i = 0; i < n; i++)
{
parent[i] = i;
}
}
int find(int x)
{
return (parent[x] == x) ? x : (parent[x] = find(parent[x]));
}
struct node
{
int val;
node *next;
node(int n) : val(n)
{
next = nullptr;
}
node()
{
next = nullptr;
}
};
void my_union(int dx, int dy)
{
parent[find(dx)] = find(dy);
return;
}
node head[N], *tail[N]; // 存图
int main()
{
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
{
tail[i] = &head[i];
}
for (int i = 0; i < m; i++)
{
int a, b;
cin >> a >> b;
tail[a]->next = new node(b);
tail[b]->next = new node(a);
tail[a] = tail[a]->next;
tail[b] = tail[b]->next;
}
/*for(int i=0;i<n;i++){
node *p=&head[i];
cout<<i<<"->";
while(p->next!=nullptr){
p=p->next;
cout<<p->val<<"->";
}
cout<<endl;
}*/
memset(cnt, 0, sizeof(cnt));
memset(g, 1, sizeof(g));
init(n);
int k;
cin >> k;
for (int i = 1; i <= k; i++)
{
cin >> b[i];
int w = b[i];
g[w] = 0;
}
for (int i = 0; i < n; i++)
{
if (g[i] == 0)
continue;
node *p = &head[i];
while (p->next != nullptr)
{
p = p->next;
if (g[p->val] == false)
continue;
my_union(p->val, i);
}
}
int sum = 0; // 最后都攻击完的时候
for (int i = 0; i < n; i++)
{
if (!cnt[find(parent[i])])
{
sum++;
cnt[find(parent[i])] = true;
}
}
sum -= k;
ans[k] = sum;
int tmp = -1, w;
for (int i = k; i >= 1; i--)
{
tmp = -1;
w = b[i];
g[w] = 1;
node *p = &head[w];
while (p->next != nullptr)
{
p = p->next;
if (g[p->val] == false)
continue;
if (find(w) != find(p->val))
{
tmp++;
my_union(w, p->val);
}
}
sum -= tmp;
ans[i - 1] = sum;
}
for (int i = 0; i <= k; i++)
{
cout << ans[i] << endl;
}
return 0;
} | 这里是题目描述：# [JSOI2008] 星球大战
## 题目描述
很久以前，在一个遥远的星系，一个黑暗的帝国靠着它的超级武器统治着整个星系。
某一天，凭着一个偶然的机遇，一支反抗军摧毁了帝国的超级武器，并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直接或间接地连接。
但好景不长，很快帝国又重新造出了他的超级武器。凭借这超级武器的力量，帝国开始有计划地摧毁反抗军占领的星球。由于星球的不断被摧毁，两个星球之间的通讯通道也开始不可靠起来。
现在，反抗军首领交给你一个任务：给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序，以尽量快的速度求出每一次打击之后反抗军占据的星球的连通块的个数。（如果两个星球可以通过现存的以太通道直接或间接地连通，则这两个星球在同一个连通块中）。
## 输入格式
输入文件第一行包含两个整数，$n,m$，分别表示星球的数目和以太隧道的数目。星球用 $0 \sim n-1$ 的整数编号。
接下来的 $m$ 行，每行包括两个整数 $x,y$，表示星球 $x$ 和星球 $y$ 之间有 “以太” 隧道，可以直接通讯。
接下来的一行为一个整数 $k$ ，表示将遭受攻击的星球的数目。
接下来的 $k$ 行，每行有一个整数，按照顺序列出了帝国军的攻击目标。这 $k$ 个数互不相同，且都在 $0$ 到 $n-1$ 的范围内。
## 输出格式
第一行是开始时星球的连通块个数。接下来的 $k$ 行，每行一个整数，表示经过该次打击后现存星球的连通块个数。
## 样例 #1
### 样例输入 #1
```
8 13
0 1
1 6
6 5
5 0
0 6
1 2
2 3
3 4
4 5
7 1
7 2
7 6
3 6
5
1
6
3
5
7
```
### 样例输出 #1
```
1
1
1
2
3
3
```
## 提示
【数据范围】
对于 $100\%$ 的数据，$1\le m \le 2\times 10^5$，$1\le n \le 2m$，$x \neq y$。
[JSOI2008] 下面是题目解析和做法：第一份题解：
这道题看似很长其实也不是十分的难
如果我们去正这摧毁 想想都有点困难
要不 我们使用逆向思维？
没错 这道题就把摧毁转换成修建~~（和平就是好）~~
利用并查集判断联通就好了
```cpp
#include<iostream>
#include<cstdio>
#define f(i,a,b) for(register int i=a;i<=b;i++)
#define fd(i,a,b) for(register int i=a;i>=b;i--)
using namespace std;
int k,n,m,head[400002],tot,broken[400002],ans[400003];
int father[400003];
struct Node
{
int next,node,from;
}h[400002];
inline void Add_Node(int u,int v)
{
h[++tot].from=u;
h[tot].next=head[u];
head[u]=tot;
h[tot].node=v;
}
bool Broken[400001];
inline int Get_father(int x)
{
if(father[x]==x) return x;
return father[x]=Get_father(father[x]);
//你爸爸的爸爸就是你的爸爸——反查理马特——并查集
}
inline void hb(int u,int v)
{
u=Get_father(u),v=Get_father(v);
if(u!=v) father[v]=u;
}
int main()
{
ios::sync_with_stdio(false);
cin>>n>>m;
f(i,0,n)
father[i]=i,head[i]=-1;//并查集初始化
f(i,1,m)
{
int x,y;
cin>>x>>y;
Add_Node(x,y);//储存图
Add_Node(y,x);//由于无向图存两遍
}
cin>>k;
f(i,1,k)
{
cin>>broken[i];
Broken[broken[i]]=1;//标记砸坏了
}
int total=n-k;//初始化为所有点都是单独存在的
f(i,1,2*m)//有2*m个边
if(!Broken[h[i].from] && !Broken[h[i].node] && Get_father(h[i].from)!=Get_father(h[i].node))
{//要是起点和终点都没砸坏 而且他们并没有联通
total--;//连一条边 减一个联通体
hb(h[i].from,h[i].node);
}
ans[k+1]=total;//当前就是最后一次破坏后的个数
fd(i,k,1)
{
//total=0 //这里不需要初始化 需要从上一次的废墟上修建
total++;//修复一个点 联通体+1
Broken[broken[i]]=0;//修复
for(int j=head[broken[i]];j!=-1;j=h[j].next)//枚举每一个子点
{
if(!Broken[h[j].node] && Get_father(broken[i])!=Get_father(h[j].node))
{
total--;//连一边减一个联通块
hb(broken[i],h[j].node);//合并这两个点
}
}
ans[i]=total;
}
f(i,1,k+1) cout<<ans[i]<<endl;
return 0;
}
```
第二个题解：
题目标签：并 查 集 | #include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
int parent[N];
int b[N]; // 在i时刻被毁灭的星球为b[i];
bool g[N]; // 判断该点还是否在图中
int cnt[N]; // 判断该连通图是否计数
int ans[N];
void init(int n)
{
for (int i = 0; i < n; i++)
{
parent[i] = i;
}
}
int find(int x)
{
return (parent[x] == x) ? x : (parent[x] = find(parent[x]));
}
struct node
{
int val;
node *next;
node(int n) : val(n)
{
next = nullptr;
}
node()
{
next = nullptr;
}
};
void my_union(int dx, int dy)
{
parent[find(dx)] = find(dy);
return;
}
node head[N], *tail[N]; // 存图
int main()
{
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
{
tail[i] = &head[i];
}
for (int i = 0; i < m; i++)
{
int a, b;
cin >> a >> b;
tail[a]->next = new node(b);
tail[b]->next = new node(a);
tail[a] = tail[a]->next;
tail[b] = tail[b]->next;
}
/*for(int i=0;i<n;i++){
node *p=&head[i];
cout<<i<<"->";
while(p->next!=nullptr){
p=p->next;
cout<<p->val<<"->";
}
cout<<endl;
}*/
memset(cnt, 0, sizeof(cnt));
memset(g, 1, sizeof(g));
init(n);
int k;
cin >> k;
for (int i = 1; i <= k; i++)
{
cin >> b[i];
int w = b[i];
g[w] = 0;
}
for (int i = 0; i < n; i++)
{
if (g[i] == 0)
continue;
node *p = &head[i];
while (p->next != nullptr)
{
p = p->next;
if (g[p->val] == false)
continue;
my_union(p->val, i);
}
}
int sum = 0; // 最后都攻击完的时候
for (int i = 0; i < n; i++)
{
if (!cnt[parent[i]])
{
sum++;
cnt[parent[i]] = true;
}
}
sum -= k;
ans[k] = sum;
int tmp = -1, w;
for (int i = k; i >= 1; i--)
{
tmp = -1;
w = b[i];
g[w] = 1;
node *p = &head[w];
while (p->next != nullptr)
{
p = p->next;
if (g[p->val] == false)
continue;
if (find(w) != find(p->val))
{
tmp++;
my_union(w, p->val);
}
}
sum -= tmp;
ans[i - 1] = sum;
}
for (int i = 0; i <= k; i++)
{
cout << ans[i] << endl;
}
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long
#define debug(p) \
for (auto i : p) \
cerr << i << " "; \
cerr << endl;
#define debugs(p) \
for (auto i : p) \
cerr << i.first << " " << i.second << endl;
typedef pair<int, int> pll;
string yes = "YES";
string no = "NO";
constexpr int N = 5e5 + 7;
vector<pll> edge[N];
int dp[N], deg[N], ans[N];
int cur = 0;
void dfs(int u, int f)
{
int cnt = 0, sum = 0;
for (auto [v, d] : edge[u])
{
if (v == f)
continue;
cnt++;
dfs(v, u);
dp[u] = max(dp[u], dp[v] + d);
ans[u] += ans[v];
sum += dp[v] + d;
}
ans[u] += cnt * dp[u] - sum;
}
void solve()
{
int n, s;
cin >> n >> s;
for (int i = 1; i < n; i++)
{
int u, v, d;
cin >> u >> v >> d;
edge[u].push_back({v, d});
edge[v].push_back({u, d});
deg[u]++;
deg[v]++;
}
dfs(s, -1);
cout << ans[s] << endl;
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int T = 1;
// cin >> T;
while (T--)
{
solve();
}
} | 这里是题目描述：# [ZJOI2007] 时态同步
## 题目描述
小 Q 在电子工艺实习课上学习焊接电路板。一块电路板由若干个元件组成，我们不妨称之为节点，并将其用数字 $1,2,3\cdots$ 进行标号。电路板的各个节点由若干不相交的导线相连接，且对于电路板的任何两个节点，都存在且仅存在一条通路（通路指连接两个元件的导线序列）。
在电路板上存在一个特殊的元件称为“激发器”。当激发器工作后，产生一个激励电流，通过导线传向每一个它所连接的节点。而中间节点接收到激励电流后，得到信息，并将该激励电流传向与它连接并且尚未接收到激励电流的节点。最终，激烈电流将到达一些“终止节点”――接收激励电流之后不再转发的节点。
激励电流在导线上的传播是需要花费时间的，对于每条边 $e$，激励电流通过它需要的时间为 $t_e$，而节点接收到激励电流后的转发可以认为是在瞬间完成的。现在这块电路板要求每一个“终止节点”同时得到激励电路――即保持时态同步。由于当前的构造并不符合时态同步的要求，故需要通过改变连接线的构造。目前小 Q 有一个道具，使用一次该道具，可以使得激励电流通过某条连接导线的时间增加一个单位。请问小 Q 最少使用多少次道具才可使得所有的“终止节点”时态同步？
## 输入格式
第一行包含一个正整数 $N$，表示电路板中节点的个数。
第二行包含一个整数 $S$，为该电路板的激发器的编号。
接下来 $N-1$ 行，每行三个整数 $a,b,t$。表示该条导线连接节点 $a$ 与节点 $b$，且激励电流通过这条导线需要 $t$ 个单位时间。
## 输出格式
仅包含一个整数 $V$，为小 Q 最少使用的道具次数。
## 样例 #1
### 样例输入 #1
```
3
1
1 2 1
1 3 3
```
### 样例输出 #1
```
2
```
## 提示
- 对于 $40\%$ 的数据，$1\le N\le 1000$。
- 对于 $100\%$ 的数据，$1\le N\le 5\times 10^5$。
对于所有的数据，$1\le t_e\le 10^6$。 下面是题目解析和做法：第一份题解：
题意让我们用最少的代价把叶子节点到根节点的距离调成相同
显然，我们调整靠近根节点的树枝，其下叶子节点距离根节点的距离都会增加，所以，**调整越靠根节点的树枝调整的代价越少**。
为了方便作图，效果直观，在此我们用**节点深度**类比**距离**
所以我们可以先找到最深的叶子节点
再从**最小的子树**开始，把所有子节点调整到**同一深度**，再调整子树上面的树枝
理解不了的话看这个图：
这样我们就可以保证用最少的代价把所有叶子节点调整到同一深度
我们理解了这个问题就可以设计dfs了
每次调整的代价都是$dis[x]-(dis[ver[i]+edge[i])$
把它累加即可
下面是详细代码
```
#include<bits/stdc++.h>
using namespace std;
const int N=500010;
int head[N],ver[N],next[N],tot,n,st,edge[N];
long long ans,dis[N];
void add(int x,int y,int z)//建图
{
ver[++tot]=y;
edge[tot]=z;
next[tot]=head[x];
head[x]=tot;
}
void dfs(int x,int fa)
{
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
dfs(y,x);//继续搜子树
dis[x]=max(dis[x],dis[y]+z);更新这棵子树根节点和叶子节点的最大距离
}
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
ans+=dis[x]-(dis[y]+z);//累加每次调整的代价
}
}
int main()
{
scanf("%d%d",&n,&st);
for(int i=1;i<n;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);add(y,x,z);//注意双向边
}
dfs(st,0);
printf("%lld",ans);
return 0;
}
```
第二份题解：
# 思路
看输入数据，由于n个节点只有n-1条边，不难看出这是一棵树。我们可以反着思考，就是让所有叶子节点同时发出信号，然后这些信号同时到达根节点。于是我们可以自下而上的进行维护，使得每一节点所有子节点的信号同时到达该节点。
于是我们考虑如何维护。我们从根节点开始搜索，搜索到叶子节点，回溯的时候进行维护，先维护节点的所有子节点到该节点最大边权（边权为**叶子**节点到同时到达它所需要时间）。然后维护答案，答案为最大边权减去所有到子节点的边权。然后维护父节点的边权，父节点边权为该节点子节点的 最大边权+父节点到该节点的时间。然后就回溯，重复操作，到根节点为止。~~好难说清楚啊QWQ 看注释更明白一点~~
然后我们要注意一些细节：
1. 一定要双向加边，是无向图。
2. 既然是无向图，维护时不要把到父节点的边计算了。
3. 维护的顺序一定不能乱。
4. 答案要用long long 存。
# 代码
```
#include <bits/stdc++.h >#define MAXN 1000005
using namespace std;
struct Edge{int next,to,dis;} edge[MAXN];
int n,s,a,b,t,maxn[MAXN],cnt,head[MAXN]; //maxn储存到子节点的最大边权
long long ans; //注意，答案要用long long 存
void addedge(int from, int to, int dis)
{
edge[++cnt].next=head[from];
edge[cnt].to=to;
edge[cnt].dis=dis;
head[from]=cnt;
} //前向星加边
void dfs(int x, int fa) //X为当前搜索节点，fa为x的父亲节点
{
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) dfs(edge[i].to, x);
//这一句一定要最先，先搜索到底层，回溯时再进行后续处理（从下向上维护）
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) maxn[x]=max(maxn[x], edge[i].dis);
//维护到子节点的最大边权
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) ans+=(maxn[x]-edge[i].dis);
//维护答案
for(int i=head[fa]; i; i=edge[i].next)
if(edge[i].to==x) edge[i].dis+=maxn[x];
//这一句不能漏，更新父节点到该节点的边权
}//注意顺序不能乱
int main()
{
scanf("%d%d ",&n,&s);
for(int i=1; i <=n-1; i++)
{
scanf("%d%d%d ",&a,&b,&t);
addedge(a, b, t);
addedge(b, a, t); //是无向图，双向加边
}
dfs(s, 0);
printf("%lld\n ",ans);
return 0;
}
``` 题目标签：树 形 动 态 规 划 | #include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long
#define debug(p) \
for (auto i : p) \
cerr << i << " "; \
cerr << endl;
#define debugs(p) \
for (auto i : p) \
cerr << i.first << " " << i.second << endl;
typedef pair<int, int> pll;
string yes = "YES";
string no = "NO";
constexpr int N = 5e5 + 7;
vector<pll> edge[N];
int dp[N], deg[N], siz[N];
pll fa[N];
int cur = 0;
void dfs(int u, int f)
{
for (auto [v, d] : edge[u])
{
if (v == f)
continue;
fa[v] = {u, d};
dfs(v, u);
dp[u] = max(dp[u], dp[v] + d);
siz[u] += siz[v];
}
}
void solve()
{
int n, s;
cin >> n >> s;
for (int i = 1; i < n; i++)
{
int u, v, d;
cin >> u >> v >> d;
edge[u].push_back({v, d});
edge[v].push_back({u, d});
deg[u]++;
deg[v]++;
}
int cnt = 0;
for (int i = 1; i <= n; i++)
{
if (deg[i] == 1 && i != s)
{
cnt++;
siz[i] = 1;
}
}
dfs(s, -1);
for (int i = 1; i <= n; i++)
{
if (i == s)
continue;
cur += siz[i] * fa[i].second;
}
// cerr<<cnt<<" "<<dp[s]<<" "<<cur<<endl;
cout << cnt * dp[s] - cur << endl;
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int T = 1;
// cin >> T;
while (T--)
{
solve();
}
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
int h[N], e[N * 2], w[N * 2], idx, ne[N * 2];
long long f[N];
void add(int a, int b, int c)
{
e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
long long n, s, ans;
long long dfs_u(int u, int fa)
{
long long maxn = 0;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (j == fa)
continue;
maxn = max(maxn, dfs_u(j, u) + w[i]);
}
f[u] = maxn;
// cout<<u<<" "<<f[u]<<endl;
return f[u] = maxn;
}
long long dfs(int u, int fa, long long dis)
{
long long sum = 0, cnt = dis;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (j == fa)
continue;
cnt = min(dis - f[j] - w[i], cnt);
}
sum = cnt;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (j == fa)
continue;
sum += dfs(j, u, dis - cnt - w[i]);
}
return sum;
}
int main()
{
memset(h, -1, sizeof(h));
cin >> n >> s;
int a, b, t;
for (int i = 1; i <= n - 1; i++)
{
cin >> a >> b >> t;
add(a, b, t);
add(b, a, t);
}
dfs_u(s, -1);
cout << dfs(s, -1, f[s]);
return 0;
}
| 这里是题目描述：# [ZJOI2007] 时态同步
## 题目描述
小 Q 在电子工艺实习课上学习焊接电路板。一块电路板由若干个元件组成，我们不妨称之为节点，并将其用数字 $1,2,3\cdots$ 进行标号。电路板的各个节点由若干不相交的导线相连接，且对于电路板的任何两个节点，都存在且仅存在一条通路（通路指连接两个元件的导线序列）。
在电路板上存在一个特殊的元件称为“激发器”。当激发器工作后，产生一个激励电流，通过导线传向每一个它所连接的节点。而中间节点接收到激励电流后，得到信息，并将该激励电流传向与它连接并且尚未接收到激励电流的节点。最终，激烈电流将到达一些“终止节点”――接收激励电流之后不再转发的节点。
激励电流在导线上的传播是需要花费时间的，对于每条边 $e$，激励电流通过它需要的时间为 $t_e$，而节点接收到激励电流后的转发可以认为是在瞬间完成的。现在这块电路板要求每一个“终止节点”同时得到激励电路――即保持时态同步。由于当前的构造并不符合时态同步的要求，故需要通过改变连接线的构造。目前小 Q 有一个道具，使用一次该道具，可以使得激励电流通过某条连接导线的时间增加一个单位。请问小 Q 最少使用多少次道具才可使得所有的“终止节点”时态同步？
## 输入格式
第一行包含一个正整数 $N$，表示电路板中节点的个数。
第二行包含一个整数 $S$，为该电路板的激发器的编号。
接下来 $N-1$ 行，每行三个整数 $a,b,t$。表示该条导线连接节点 $a$ 与节点 $b$，且激励电流通过这条导线需要 $t$ 个单位时间。
## 输出格式
仅包含一个整数 $V$，为小 Q 最少使用的道具次数。
## 样例 #1
### 样例输入 #1
```
3
1
1 2 1
1 3 3
```
### 样例输出 #1
```
2
```
## 提示
- 对于 $40\%$ 的数据，$1\le N\le 1000$。
- 对于 $100\%$ 的数据，$1\le N\le 5\times 10^5$。
对于所有的数据，$1\le t_e\le 10^6$。 下面是题目解析和做法：第一份题解：
题意让我们用最少的代价把叶子节点到根节点的距离调成相同
显然，我们调整靠近根节点的树枝，其下叶子节点距离根节点的距离都会增加，所以，**调整越靠根节点的树枝调整的代价越少**。
为了方便作图，效果直观，在此我们用**节点深度**类比**距离**
所以我们可以先找到最深的叶子节点
再从**最小的子树**开始，把所有子节点调整到**同一深度**，再调整子树上面的树枝
理解不了的话看这个图：
这样我们就可以保证用最少的代价把所有叶子节点调整到同一深度
我们理解了这个问题就可以设计dfs了
每次调整的代价都是$dis[x]-(dis[ver[i]+edge[i])$
把它累加即可
下面是详细代码
```
#include<bits/stdc++.h>
using namespace std;
const int N=500010;
int head[N],ver[N],next[N],tot,n,st,edge[N];
long long ans,dis[N];
void add(int x,int y,int z)//建图
{
ver[++tot]=y;
edge[tot]=z;
next[tot]=head[x];
head[x]=tot;
}
void dfs(int x,int fa)
{
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
dfs(y,x);//继续搜子树
dis[x]=max(dis[x],dis[y]+z);更新这棵子树根节点和叶子节点的最大距离
}
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
ans+=dis[x]-(dis[y]+z);//累加每次调整的代价
}
}
int main()
{
scanf("%d%d",&n,&st);
for(int i=1;i<n;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);add(y,x,z);//注意双向边
}
dfs(st,0);
printf("%lld",ans);
return 0;
}
```
第二份题解：
# 思路
看输入数据，由于n个节点只有n-1条边，不难看出这是一棵树。我们可以反着思考，就是让所有叶子节点同时发出信号，然后这些信号同时到达根节点。于是我们可以自下而上的进行维护，使得每一节点所有子节点的信号同时到达该节点。
于是我们考虑如何维护。我们从根节点开始搜索，搜索到叶子节点，回溯的时候进行维护，先维护节点的所有子节点到该节点最大边权（边权为**叶子**节点到同时到达它所需要时间）。然后维护答案，答案为最大边权减去所有到子节点的边权。然后维护父节点的边权，父节点边权为该节点子节点的 最大边权+父节点到该节点的时间。然后就回溯，重复操作，到根节点为止。~~好难说清楚啊QWQ 看注释更明白一点~~
然后我们要注意一些细节：
1. 一定要双向加边，是无向图。
2. 既然是无向图，维护时不要把到父节点的边计算了。
3. 维护的顺序一定不能乱。
4. 答案要用long long 存。
# 代码
```
#include <bits/stdc++.h >#define MAXN 1000005
using namespace std;
struct Edge{int next,to,dis;} edge[MAXN];
int n,s,a,b,t,maxn[MAXN],cnt,head[MAXN]; //maxn储存到子节点的最大边权
long long ans; //注意，答案要用long long 存
void addedge(int from, int to, int dis)
{
edge[++cnt].next=head[from];
edge[cnt].to=to;
edge[cnt].dis=dis;
head[from]=cnt;
} //前向星加边
void dfs(int x, int fa) //X为当前搜索节点，fa为x的父亲节点
{
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) dfs(edge[i].to, x);
//这一句一定要最先，先搜索到底层，回溯时再进行后续处理（从下向上维护）
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) maxn[x]=max(maxn[x], edge[i].dis);
//维护到子节点的最大边权
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) ans+=(maxn[x]-edge[i].dis);
//维护答案
for(int i=head[fa]; i; i=edge[i].next)
if(edge[i].to==x) edge[i].dis+=maxn[x];
//这一句不能漏，更新父节点到该节点的边权
}//注意顺序不能乱
int main()
{
scanf("%d%d ",&n,&s);
for(int i=1; i <=n-1; i++)
{
scanf("%d%d%d ",&a,&b,&t);
addedge(a, b, t);
addedge(b, a, t); //是无向图，双向加边
}
dfs(s, 0);
printf("%lld\n ",ans);
return 0;
}
``` 题目标签：树 形 动 态 规 划 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
int h[N], e[N * 2], w[N * 2], idx, ne[N * 2];
void add(int a, int b, int c)
{
e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
int n, s, ans;
int dfs_u(int u, int fa)
{
int maxn = 0;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (j == fa)
continue;
maxn = max(maxn, dfs_u(j, u) + w[i]);
}
return maxn;
}
int dfs(int u, int fa, int dis)
{
int sum = dis;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (j == fa)
continue;
sum += dfs(j, u, dis - w[i]);
}
return sum;
}
int main()
{
memset(h, -1, sizeof(h));
cin >> n >> s;
int a, b, t;
for (int i = 1; i <= n - 1; i++)
{
cin >> a >> b >> t;
add(a, b, t);
add(b, a, t);
}
ans = dfs_u(s, -1);
cout << dfs(s, -1, ans) - ans;
return 0;
}
| 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
vector<pair<int, int>> g[500005];
int mx[500005], ans, n, s, to;
void pfs(int u, int f, int sum)
{
mx[u] = sum;
for (auto [v, w] : g[u])
if (v != f)
pfs(v, u, sum + w), mx[u] = max(mx[v], mx[u]);
}
void dfs(int u, int f, int sum)
{
ans += to - mx[u] - sum;
for (auto [v, w] : g[u])
if (v != f)
dfs(v, u, sum + to - mx[u] - sum);
}
signed main()
{
cin >> n >> s;
for (int u, v, w, i = 1; i < n; i++)
{
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
pfs(s, 0, 0);
to = mx[s];
dfs(s, 0, 0);
cout << ans << "\n";
} | 这里是题目描述：# [ZJOI2007] 时态同步
## 题目描述
小 Q 在电子工艺实习课上学习焊接电路板。一块电路板由若干个元件组成，我们不妨称之为节点，并将其用数字 $1,2,3\cdots$ 进行标号。电路板的各个节点由若干不相交的导线相连接，且对于电路板的任何两个节点，都存在且仅存在一条通路（通路指连接两个元件的导线序列）。
在电路板上存在一个特殊的元件称为“激发器”。当激发器工作后，产生一个激励电流，通过导线传向每一个它所连接的节点。而中间节点接收到激励电流后，得到信息，并将该激励电流传向与它连接并且尚未接收到激励电流的节点。最终，激烈电流将到达一些“终止节点”――接收激励电流之后不再转发的节点。
激励电流在导线上的传播是需要花费时间的，对于每条边 $e$，激励电流通过它需要的时间为 $t_e$，而节点接收到激励电流后的转发可以认为是在瞬间完成的。现在这块电路板要求每一个“终止节点”同时得到激励电路――即保持时态同步。由于当前的构造并不符合时态同步的要求，故需要通过改变连接线的构造。目前小 Q 有一个道具，使用一次该道具，可以使得激励电流通过某条连接导线的时间增加一个单位。请问小 Q 最少使用多少次道具才可使得所有的“终止节点”时态同步？
## 输入格式
第一行包含一个正整数 $N$，表示电路板中节点的个数。
第二行包含一个整数 $S$，为该电路板的激发器的编号。
接下来 $N-1$ 行，每行三个整数 $a,b,t$。表示该条导线连接节点 $a$ 与节点 $b$，且激励电流通过这条导线需要 $t$ 个单位时间。
## 输出格式
仅包含一个整数 $V$，为小 Q 最少使用的道具次数。
## 样例 #1
### 样例输入 #1
```
3
1
1 2 1
1 3 3
```
### 样例输出 #1
```
2
```
## 提示
- 对于 $40\%$ 的数据，$1\le N\le 1000$。
- 对于 $100\%$ 的数据，$1\le N\le 5\times 10^5$。
对于所有的数据，$1\le t_e\le 10^6$。 下面是题目解析和做法：第一份题解：
题意让我们用最少的代价把叶子节点到根节点的距离调成相同
显然，我们调整靠近根节点的树枝，其下叶子节点距离根节点的距离都会增加，所以，**调整越靠根节点的树枝调整的代价越少**。
为了方便作图，效果直观，在此我们用**节点深度**类比**距离**
所以我们可以先找到最深的叶子节点
再从**最小的子树**开始，把所有子节点调整到**同一深度**，再调整子树上面的树枝
理解不了的话看这个图：
这样我们就可以保证用最少的代价把所有叶子节点调整到同一深度
我们理解了这个问题就可以设计dfs了
每次调整的代价都是$dis[x]-(dis[ver[i]+edge[i])$
把它累加即可
下面是详细代码
```
#include<bits/stdc++.h>
using namespace std;
const int N=500010;
int head[N],ver[N],next[N],tot,n,st,edge[N];
long long ans,dis[N];
void add(int x,int y,int z)//建图
{
ver[++tot]=y;
edge[tot]=z;
next[tot]=head[x];
head[x]=tot;
}
void dfs(int x,int fa)
{
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
dfs(y,x);//继续搜子树
dis[x]=max(dis[x],dis[y]+z);更新这棵子树根节点和叶子节点的最大距离
}
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
ans+=dis[x]-(dis[y]+z);//累加每次调整的代价
}
}
int main()
{
scanf("%d%d",&n,&st);
for(int i=1;i<n;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);add(y,x,z);//注意双向边
}
dfs(st,0);
printf("%lld",ans);
return 0;
}
```
第二份题解：
# 思路
看输入数据，由于n个节点只有n-1条边，不难看出这是一棵树。我们可以反着思考，就是让所有叶子节点同时发出信号，然后这些信号同时到达根节点。于是我们可以自下而上的进行维护，使得每一节点所有子节点的信号同时到达该节点。
于是我们考虑如何维护。我们从根节点开始搜索，搜索到叶子节点，回溯的时候进行维护，先维护节点的所有子节点到该节点最大边权（边权为**叶子**节点到同时到达它所需要时间）。然后维护答案，答案为最大边权减去所有到子节点的边权。然后维护父节点的边权，父节点边权为该节点子节点的 最大边权+父节点到该节点的时间。然后就回溯，重复操作，到根节点为止。~~好难说清楚啊QWQ 看注释更明白一点~~
然后我们要注意一些细节：
1. 一定要双向加边，是无向图。
2. 既然是无向图，维护时不要把到父节点的边计算了。
3. 维护的顺序一定不能乱。
4. 答案要用long long 存。
# 代码
```
#include <bits/stdc++.h >#define MAXN 1000005
using namespace std;
struct Edge{int next,to,dis;} edge[MAXN];
int n,s,a,b,t,maxn[MAXN],cnt,head[MAXN]; //maxn储存到子节点的最大边权
long long ans; //注意，答案要用long long 存
void addedge(int from, int to, int dis)
{
edge[++cnt].next=head[from];
edge[cnt].to=to;
edge[cnt].dis=dis;
head[from]=cnt;
} //前向星加边
void dfs(int x, int fa) //X为当前搜索节点，fa为x的父亲节点
{
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) dfs(edge[i].to, x);
//这一句一定要最先，先搜索到底层，回溯时再进行后续处理（从下向上维护）
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) maxn[x]=max(maxn[x], edge[i].dis);
//维护到子节点的最大边权
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) ans+=(maxn[x]-edge[i].dis);
//维护答案
for(int i=head[fa]; i; i=edge[i].next)
if(edge[i].to==x) edge[i].dis+=maxn[x];
//这一句不能漏，更新父节点到该节点的边权
}//注意顺序不能乱
int main()
{
scanf("%d%d ",&n,&s);
for(int i=1; i <=n-1; i++)
{
scanf("%d%d%d ",&a,&b,&t);
addedge(a, b, t);
addedge(b, a, t); //是无向图，双向加边
}
dfs(s, 0);
printf("%lld\n ",ans);
return 0;
}
``` 题目标签：树 形 动 态 规 划 | #include <bits/stdc++.h>
#define int long long
using namespace std;
vector<pair<int, int>> g[500005];
int mx[500005], ans, n, s, to;
void pfs(int u, int f, int sum)
{
mx[u] = sum;
for (auto [v, w] : g[u])
if (v != f)
pfs(v, u, sum + w), mx[u] = max(mx[v], mx[u]);
}
void dfs(int u, int f, int sum)
{
ans += to - mx[u] - sum;
for (auto [v, w] : g[u])
if (v != f)
dfs(v, u, sum + to - mx[u] - sum);
}
signed main()
{
cin >> n >> s;
for (int u, v, w, i = 1; i < n; i++)
{
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
pfs(1, 0, 0);
to = mx[1];
dfs(1, 0, 0);
cout << ans << "\n";
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
#define itn int
#define LL long long
#define int long long
signed main()
{
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
int n, s;
std::cin >> n >> s;
std::vector<int> sum(n + 1);
std::vector<std::vector<int>> gragh(n + 1);
std::unordered_map<int, int> fath;
std::vector<std::vector<int>> info(n + 1, std::vector<int>(3));
for (int i = 0; i < n - 1; i++)
{
std::cin >> info[i][0] >> info[i][1] >> info[i][2];
gragh[info[i][0]].push_back(info[i][1]);
gragh[info[i][1]].push_back(info[i][0]);
}
std::function<void(int, int)> init = [&](int i, int f)
{
for (int j : gragh[i])
if (j != f)
{
fath[j] = i;
init(j, i);
}
};
init(s, 0);
for (int i = 0; i < n - 1; i++)
{
if (fath[info[i][1]] == info[i][0])
sum[info[i][1]] = info[i][2];
else
sum[info[i][0]] = info[i][2];
}
int ans = 0;
std::function<void(int)> dfs = [&](int i)
{
std::priority_queue<int> q;
for (int j : gragh[i])
if (j != fath[i])
{
dfs(j);
q.push(sum[j]);
}
int Max = 0;
if (!q.empty())
Max = q.top();
sum[i] += Max;
for (int j : gragh[i])
if (j != fath[i])
ans += std::abs(Max - sum[j]);
};
dfs(s);
std::cout << ans;
} | 这里是题目描述：# [ZJOI2007] 时态同步
## 题目描述
小 Q 在电子工艺实习课上学习焊接电路板。一块电路板由若干个元件组成，我们不妨称之为节点，并将其用数字 $1,2,3\cdots$ 进行标号。电路板的各个节点由若干不相交的导线相连接，且对于电路板的任何两个节点，都存在且仅存在一条通路（通路指连接两个元件的导线序列）。
在电路板上存在一个特殊的元件称为“激发器”。当激发器工作后，产生一个激励电流，通过导线传向每一个它所连接的节点。而中间节点接收到激励电流后，得到信息，并将该激励电流传向与它连接并且尚未接收到激励电流的节点。最终，激烈电流将到达一些“终止节点”――接收激励电流之后不再转发的节点。
激励电流在导线上的传播是需要花费时间的，对于每条边 $e$，激励电流通过它需要的时间为 $t_e$，而节点接收到激励电流后的转发可以认为是在瞬间完成的。现在这块电路板要求每一个“终止节点”同时得到激励电路――即保持时态同步。由于当前的构造并不符合时态同步的要求，故需要通过改变连接线的构造。目前小 Q 有一个道具，使用一次该道具，可以使得激励电流通过某条连接导线的时间增加一个单位。请问小 Q 最少使用多少次道具才可使得所有的“终止节点”时态同步？
## 输入格式
第一行包含一个正整数 $N$，表示电路板中节点的个数。
第二行包含一个整数 $S$，为该电路板的激发器的编号。
接下来 $N-1$ 行，每行三个整数 $a,b,t$。表示该条导线连接节点 $a$ 与节点 $b$，且激励电流通过这条导线需要 $t$ 个单位时间。
## 输出格式
仅包含一个整数 $V$，为小 Q 最少使用的道具次数。
## 样例 #1
### 样例输入 #1
```
3
1
1 2 1
1 3 3
```
### 样例输出 #1
```
2
```
## 提示
- 对于 $40\%$ 的数据，$1\le N\le 1000$。
- 对于 $100\%$ 的数据，$1\le N\le 5\times 10^5$。
对于所有的数据，$1\le t_e\le 10^6$。 下面是题目解析和做法：第一份题解：
题意让我们用最少的代价把叶子节点到根节点的距离调成相同
显然，我们调整靠近根节点的树枝，其下叶子节点距离根节点的距离都会增加，所以，**调整越靠根节点的树枝调整的代价越少**。
为了方便作图，效果直观，在此我们用**节点深度**类比**距离**
所以我们可以先找到最深的叶子节点
再从**最小的子树**开始，把所有子节点调整到**同一深度**，再调整子树上面的树枝
理解不了的话看这个图：
这样我们就可以保证用最少的代价把所有叶子节点调整到同一深度
我们理解了这个问题就可以设计dfs了
每次调整的代价都是$dis[x]-(dis[ver[i]+edge[i])$
把它累加即可
下面是详细代码
```
#include<bits/stdc++.h>
using namespace std;
const int N=500010;
int head[N],ver[N],next[N],tot,n,st,edge[N];
long long ans,dis[N];
void add(int x,int y,int z)//建图
{
ver[++tot]=y;
edge[tot]=z;
next[tot]=head[x];
head[x]=tot;
}
void dfs(int x,int fa)
{
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
dfs(y,x);//继续搜子树
dis[x]=max(dis[x],dis[y]+z);更新这棵子树根节点和叶子节点的最大距离
}
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
ans+=dis[x]-(dis[y]+z);//累加每次调整的代价
}
}
int main()
{
scanf("%d%d",&n,&st);
for(int i=1;i<n;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);add(y,x,z);//注意双向边
}
dfs(st,0);
printf("%lld",ans);
return 0;
}
```
第二份题解：
# 思路
看输入数据，由于n个节点只有n-1条边，不难看出这是一棵树。我们可以反着思考，就是让所有叶子节点同时发出信号，然后这些信号同时到达根节点。于是我们可以自下而上的进行维护，使得每一节点所有子节点的信号同时到达该节点。
于是我们考虑如何维护。我们从根节点开始搜索，搜索到叶子节点，回溯的时候进行维护，先维护节点的所有子节点到该节点最大边权（边权为**叶子**节点到同时到达它所需要时间）。然后维护答案，答案为最大边权减去所有到子节点的边权。然后维护父节点的边权，父节点边权为该节点子节点的 最大边权+父节点到该节点的时间。然后就回溯，重复操作，到根节点为止。~~好难说清楚啊QWQ 看注释更明白一点~~
然后我们要注意一些细节：
1. 一定要双向加边，是无向图。
2. 既然是无向图，维护时不要把到父节点的边计算了。
3. 维护的顺序一定不能乱。
4. 答案要用long long 存。
# 代码
```
#include <bits/stdc++.h >#define MAXN 1000005
using namespace std;
struct Edge{int next,to,dis;} edge[MAXN];
int n,s,a,b,t,maxn[MAXN],cnt,head[MAXN]; //maxn储存到子节点的最大边权
long long ans; //注意，答案要用long long 存
void addedge(int from, int to, int dis)
{
edge[++cnt].next=head[from];
edge[cnt].to=to;
edge[cnt].dis=dis;
head[from]=cnt;
} //前向星加边
void dfs(int x, int fa) //X为当前搜索节点，fa为x的父亲节点
{
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) dfs(edge[i].to, x);
//这一句一定要最先，先搜索到底层，回溯时再进行后续处理（从下向上维护）
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) maxn[x]=max(maxn[x], edge[i].dis);
//维护到子节点的最大边权
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) ans+=(maxn[x]-edge[i].dis);
//维护答案
for(int i=head[fa]; i; i=edge[i].next)
if(edge[i].to==x) edge[i].dis+=maxn[x];
//这一句不能漏，更新父节点到该节点的边权
}//注意顺序不能乱
int main()
{
scanf("%d%d ",&n,&s);
for(int i=1; i <=n-1; i++)
{
scanf("%d%d%d ",&a,&b,&t);
addedge(a, b, t);
addedge(b, a, t); //是无向图，双向加边
}
dfs(s, 0);
printf("%lld\n ",ans);
return 0;
}
``` 题目标签：树 形 动 态 规 划 | #include <bits/stdc++.h>
#define itn int
#define LL long long
int main()
{
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
int n, s;
std::cin >> n >> s;
std::vector<int> sum(n + 1);
std::vector<std::vector<int>> gragh(n + 1);
std::unordered_map<int, int> fath;
std::vector<std::vector<int>> info(n + 1, std::vector<int>(3));
for (int i = 0; i < n - 1; i++)
{
std::cin >> info[i][0] >> info[i][1] >> info[i][2];
gragh[info[i][0]].push_back(info[i][1]);
gragh[info[i][1]].push_back(info[i][0]);
}
std::function<void(int, int)> init = [&](int i, int f)
{
for (int j : gragh[i])
if (j != f)
{
fath[j] = i;
init(j, i);
}
};
init(s, 0);
for (int i = 0; i < n - 1; i++)
{
if (fath[info[i][1]] == info[i][0])
sum[info[i][1]] = info[i][2];
else
sum[info[i][0]] = info[i][2];
}
int ans = 0;
std::function<void(int)> dfs = [&](int i)
{
std::priority_queue<int> q;
for (int j : gragh[i])
if (j != fath[i])
{
dfs(j);
q.push(sum[j]);
}
int Max = 0;
if (!q.empty())
Max = q.top();
sum[i] += Max;
for (int j : gragh[i])
if (j != fath[i])
ans += std::abs(Max - sum[j]);
};
dfs(s);
std::cout << ans;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int tot, n, gf;
int head[N], nxt[N], val[N], vet[N];
long long ans, dis[N];
void connect(int a, int b, int c)
{
vet[++tot] = b;
val[tot] = c;
nxt[tot] = head[a];
head[a] = tot;
}
void dfs(int a, int fa)
{
for (int i = head[a]; i; i = nxt[i])
{
int b = vet[i], c = val[i];
if (b == fa)
continue;
dfs(b, a);
dis[a] = max(dis[a], dis[b] + c);
}
for (int i = head[a]; i; i = nxt[i])
{
int b = vet[i], c = val[i];
if (b == fa)
continue;
ans += dis[a] - dis[b] - c;
}
}
int main()
{
// freopen("paper","r",stdin);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
while (tt--)
{
cin >> n >> gf;
for (int i = 0; i < n - 1; i++)
{
int a, b, c;
cin >> a >> b >> c;
connect(a, b, c);
connect(b, a, c);
}
dfs(gf, 0);
cout << ans;
}
return 0;
} | 这里是题目描述：# [ZJOI2007] 时态同步
## 题目描述
小 Q 在电子工艺实习课上学习焊接电路板。一块电路板由若干个元件组成，我们不妨称之为节点，并将其用数字 $1,2,3\cdots$ 进行标号。电路板的各个节点由若干不相交的导线相连接，且对于电路板的任何两个节点，都存在且仅存在一条通路（通路指连接两个元件的导线序列）。
在电路板上存在一个特殊的元件称为“激发器”。当激发器工作后，产生一个激励电流，通过导线传向每一个它所连接的节点。而中间节点接收到激励电流后，得到信息，并将该激励电流传向与它连接并且尚未接收到激励电流的节点。最终，激烈电流将到达一些“终止节点”――接收激励电流之后不再转发的节点。
激励电流在导线上的传播是需要花费时间的，对于每条边 $e$，激励电流通过它需要的时间为 $t_e$，而节点接收到激励电流后的转发可以认为是在瞬间完成的。现在这块电路板要求每一个“终止节点”同时得到激励电路――即保持时态同步。由于当前的构造并不符合时态同步的要求，故需要通过改变连接线的构造。目前小 Q 有一个道具，使用一次该道具，可以使得激励电流通过某条连接导线的时间增加一个单位。请问小 Q 最少使用多少次道具才可使得所有的“终止节点”时态同步？
## 输入格式
第一行包含一个正整数 $N$，表示电路板中节点的个数。
第二行包含一个整数 $S$，为该电路板的激发器的编号。
接下来 $N-1$ 行，每行三个整数 $a,b,t$。表示该条导线连接节点 $a$ 与节点 $b$，且激励电流通过这条导线需要 $t$ 个单位时间。
## 输出格式
仅包含一个整数 $V$，为小 Q 最少使用的道具次数。
## 样例 #1
### 样例输入 #1
```
3
1
1 2 1
1 3 3
```
### 样例输出 #1
```
2
```
## 提示
- 对于 $40\%$ 的数据，$1\le N\le 1000$。
- 对于 $100\%$ 的数据，$1\le N\le 5\times 10^5$。
对于所有的数据，$1\le t_e\le 10^6$。 下面是题目解析和做法：第一份题解：
题意让我们用最少的代价把叶子节点到根节点的距离调成相同
显然，我们调整靠近根节点的树枝，其下叶子节点距离根节点的距离都会增加，所以，**调整越靠根节点的树枝调整的代价越少**。
为了方便作图，效果直观，在此我们用**节点深度**类比**距离**
所以我们可以先找到最深的叶子节点
再从**最小的子树**开始，把所有子节点调整到**同一深度**，再调整子树上面的树枝
理解不了的话看这个图：
这样我们就可以保证用最少的代价把所有叶子节点调整到同一深度
我们理解了这个问题就可以设计dfs了
每次调整的代价都是$dis[x]-(dis[ver[i]+edge[i])$
把它累加即可
下面是详细代码
```
#include<bits/stdc++.h>
using namespace std;
const int N=500010;
int head[N],ver[N],next[N],tot,n,st,edge[N];
long long ans,dis[N];
void add(int x,int y,int z)//建图
{
ver[++tot]=y;
edge[tot]=z;
next[tot]=head[x];
head[x]=tot;
}
void dfs(int x,int fa)
{
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
dfs(y,x);//继续搜子树
dis[x]=max(dis[x],dis[y]+z);更新这棵子树根节点和叶子节点的最大距离
}
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
ans+=dis[x]-(dis[y]+z);//累加每次调整的代价
}
}
int main()
{
scanf("%d%d",&n,&st);
for(int i=1;i<n;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);add(y,x,z);//注意双向边
}
dfs(st,0);
printf("%lld",ans);
return 0;
}
```
第二份题解：
# 思路
看输入数据，由于n个节点只有n-1条边，不难看出这是一棵树。我们可以反着思考，就是让所有叶子节点同时发出信号，然后这些信号同时到达根节点。于是我们可以自下而上的进行维护，使得每一节点所有子节点的信号同时到达该节点。
于是我们考虑如何维护。我们从根节点开始搜索，搜索到叶子节点，回溯的时候进行维护，先维护节点的所有子节点到该节点最大边权（边权为**叶子**节点到同时到达它所需要时间）。然后维护答案，答案为最大边权减去所有到子节点的边权。然后维护父节点的边权，父节点边权为该节点子节点的 最大边权+父节点到该节点的时间。然后就回溯，重复操作，到根节点为止。~~好难说清楚啊QWQ 看注释更明白一点~~
然后我们要注意一些细节：
1. 一定要双向加边，是无向图。
2. 既然是无向图，维护时不要把到父节点的边计算了。
3. 维护的顺序一定不能乱。
4. 答案要用long long 存。
# 代码
```
#include <bits/stdc++.h >#define MAXN 1000005
using namespace std;
struct Edge{int next,to,dis;} edge[MAXN];
int n,s,a,b,t,maxn[MAXN],cnt,head[MAXN]; //maxn储存到子节点的最大边权
long long ans; //注意，答案要用long long 存
void addedge(int from, int to, int dis)
{
edge[++cnt].next=head[from];
edge[cnt].to=to;
edge[cnt].dis=dis;
head[from]=cnt;
} //前向星加边
void dfs(int x, int fa) //X为当前搜索节点，fa为x的父亲节点
{
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) dfs(edge[i].to, x);
//这一句一定要最先，先搜索到底层，回溯时再进行后续处理（从下向上维护）
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) maxn[x]=max(maxn[x], edge[i].dis);
//维护到子节点的最大边权
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) ans+=(maxn[x]-edge[i].dis);
//维护答案
for(int i=head[fa]; i; i=edge[i].next)
if(edge[i].to==x) edge[i].dis+=maxn[x];
//这一句不能漏，更新父节点到该节点的边权
}//注意顺序不能乱
int main()
{
scanf("%d%d ",&n,&s);
for(int i=1; i <=n-1; i++)
{
scanf("%d%d%d ",&a,&b,&t);
addedge(a, b, t);
addedge(b, a, t); //是无向图，双向加边
}
dfs(s, 0);
printf("%lld\n ",ans);
return 0;
}
``` 题目标签：树 形 动 态 规 划 | #include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int tot, n, gf;
int head[N], nxt[N], val[N], vet[N];
long long ans, dis[N];
void connect(int a, int b, int c)
{
vet[++tot] = b;
val[tot] = c;
nxt[tot] = head[a];
head[a] = tot;
}
void dfs(int a, int fa)
{
for (int i = head[a]; i; i = nxt[i])
{
int b = vet[i], c = val[i];
if (b == fa)
continue;
dfs(b, a);
dis[a] = max(dis[a], dis[b] + c);
}
for (int i = head[a]; i; i = nxt[i])
{
int b = vet[i], c = val[i];
if (b == fa)
continue;
ans += dis[a] - dis[b] - c;
}
}
int main()
{
// freopen("paper","r",stdin);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
while (tt--)
{
cin >> n >> gf;
for (int i = 0; i < n - 1; i++)
{
int a, b, c;
cin >> a >> b >> c;
connect(a, b, c);
}
dfs(gf, 0);
cout << ans;
}
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
long long n, s, dp[N], x, y, z, ans;
struct node
{
int v, w;
};
vector<node> e[N];
void dfs(int u, int fa)
{
for (auto [v, w] : e[u])
{
if (v == fa)
continue;
dfs(v, u);
dp[u] = max(dp[u], dp[v] + w);
}
for (auto [v, w] : e[u])
{
if (v == fa)
continue;
ans += dp[u] - (dp[v] + w);
}
}
int main()
{
cin >> n >> s;
for (int i = 1; i < n; i++)
{
cin >> x >> y >> z;
e[x].push_back({y, z});
e[y].push_back({x, z});
}
dfs(s, -1);
cout << ans;
return 0;
} | 这里是题目描述：# [ZJOI2007] 时态同步
## 题目描述
小 Q 在电子工艺实习课上学习焊接电路板。一块电路板由若干个元件组成，我们不妨称之为节点，并将其用数字 $1,2,3\cdots$ 进行标号。电路板的各个节点由若干不相交的导线相连接，且对于电路板的任何两个节点，都存在且仅存在一条通路（通路指连接两个元件的导线序列）。
在电路板上存在一个特殊的元件称为“激发器”。当激发器工作后，产生一个激励电流，通过导线传向每一个它所连接的节点。而中间节点接收到激励电流后，得到信息，并将该激励电流传向与它连接并且尚未接收到激励电流的节点。最终，激烈电流将到达一些“终止节点”――接收激励电流之后不再转发的节点。
激励电流在导线上的传播是需要花费时间的，对于每条边 $e$，激励电流通过它需要的时间为 $t_e$，而节点接收到激励电流后的转发可以认为是在瞬间完成的。现在这块电路板要求每一个“终止节点”同时得到激励电路――即保持时态同步。由于当前的构造并不符合时态同步的要求，故需要通过改变连接线的构造。目前小 Q 有一个道具，使用一次该道具，可以使得激励电流通过某条连接导线的时间增加一个单位。请问小 Q 最少使用多少次道具才可使得所有的“终止节点”时态同步？
## 输入格式
第一行包含一个正整数 $N$，表示电路板中节点的个数。
第二行包含一个整数 $S$，为该电路板的激发器的编号。
接下来 $N-1$ 行，每行三个整数 $a,b,t$。表示该条导线连接节点 $a$ 与节点 $b$，且激励电流通过这条导线需要 $t$ 个单位时间。
## 输出格式
仅包含一个整数 $V$，为小 Q 最少使用的道具次数。
## 样例 #1
### 样例输入 #1
```
3
1
1 2 1
1 3 3
```
### 样例输出 #1
```
2
```
## 提示
- 对于 $40\%$ 的数据，$1\le N\le 1000$。
- 对于 $100\%$ 的数据，$1\le N\le 5\times 10^5$。
对于所有的数据，$1\le t_e\le 10^6$。 下面是题目解析和做法：第一份题解：
题意让我们用最少的代价把叶子节点到根节点的距离调成相同
显然，我们调整靠近根节点的树枝，其下叶子节点距离根节点的距离都会增加，所以，**调整越靠根节点的树枝调整的代价越少**。
为了方便作图，效果直观，在此我们用**节点深度**类比**距离**
所以我们可以先找到最深的叶子节点
再从**最小的子树**开始，把所有子节点调整到**同一深度**，再调整子树上面的树枝
理解不了的话看这个图：
这样我们就可以保证用最少的代价把所有叶子节点调整到同一深度
我们理解了这个问题就可以设计dfs了
每次调整的代价都是$dis[x]-(dis[ver[i]+edge[i])$
把它累加即可
下面是详细代码
```
#include<bits/stdc++.h>
using namespace std;
const int N=500010;
int head[N],ver[N],next[N],tot,n,st,edge[N];
long long ans,dis[N];
void add(int x,int y,int z)//建图
{
ver[++tot]=y;
edge[tot]=z;
next[tot]=head[x];
head[x]=tot;
}
void dfs(int x,int fa)
{
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
dfs(y,x);//继续搜子树
dis[x]=max(dis[x],dis[y]+z);更新这棵子树根节点和叶子节点的最大距离
}
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
ans+=dis[x]-(dis[y]+z);//累加每次调整的代价
}
}
int main()
{
scanf("%d%d",&n,&st);
for(int i=1;i<n;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);add(y,x,z);//注意双向边
}
dfs(st,0);
printf("%lld",ans);
return 0;
}
```
第二份题解：
# 思路
看输入数据，由于n个节点只有n-1条边，不难看出这是一棵树。我们可以反着思考，就是让所有叶子节点同时发出信号，然后这些信号同时到达根节点。于是我们可以自下而上的进行维护，使得每一节点所有子节点的信号同时到达该节点。
于是我们考虑如何维护。我们从根节点开始搜索，搜索到叶子节点，回溯的时候进行维护，先维护节点的所有子节点到该节点最大边权（边权为**叶子**节点到同时到达它所需要时间）。然后维护答案，答案为最大边权减去所有到子节点的边权。然后维护父节点的边权，父节点边权为该节点子节点的 最大边权+父节点到该节点的时间。然后就回溯，重复操作，到根节点为止。~~好难说清楚啊QWQ 看注释更明白一点~~
然后我们要注意一些细节：
1. 一定要双向加边，是无向图。
2. 既然是无向图，维护时不要把到父节点的边计算了。
3. 维护的顺序一定不能乱。
4. 答案要用long long 存。
# 代码
```
#include <bits/stdc++.h >#define MAXN 1000005
using namespace std;
struct Edge{int next,to,dis;} edge[MAXN];
int n,s,a,b,t,maxn[MAXN],cnt,head[MAXN]; //maxn储存到子节点的最大边权
long long ans; //注意，答案要用long long 存
void addedge(int from, int to, int dis)
{
edge[++cnt].next=head[from];
edge[cnt].to=to;
edge[cnt].dis=dis;
head[from]=cnt;
} //前向星加边
void dfs(int x, int fa) //X为当前搜索节点，fa为x的父亲节点
{
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) dfs(edge[i].to, x);
//这一句一定要最先，先搜索到底层，回溯时再进行后续处理（从下向上维护）
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) maxn[x]=max(maxn[x], edge[i].dis);
//维护到子节点的最大边权
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) ans+=(maxn[x]-edge[i].dis);
//维护答案
for(int i=head[fa]; i; i=edge[i].next)
if(edge[i].to==x) edge[i].dis+=maxn[x];
//这一句不能漏，更新父节点到该节点的边权
}//注意顺序不能乱
int main()
{
scanf("%d%d ",&n,&s);
for(int i=1; i <=n-1; i++)
{
scanf("%d%d%d ",&a,&b,&t);
addedge(a, b, t);
addedge(b, a, t); //是无向图，双向加边
}
dfs(s, 0);
printf("%lld\n ",ans);
return 0;
}
``` 题目标签：树 形 动 态 规 划 | #include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int n, s, dp[N], x, y, z, ans;
struct node
{
int v, w;
};
vector<node> e[N];
void dfs(int u, int fa)
{
for (auto [v, w] : e[u])
{
if (v == fa)
continue;
dfs(v, u);
dp[u] = max(dp[u], dp[v] + w);
}
for (auto [v, w] : e[u])
{
if (v == fa)
continue;
ans += dp[u] - (dp[v] + w);
}
}
int main()
{
cin >> n >> s;
for (int i = 1; i < n; i++)
{
cin >> x >> y >> z;
e[x].push_back({y, z});
e[y].push_back({x, z});
}
dfs(s, -1);
cout << ans;
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define int long long
#define alls(x) x.begin(), x.end()
#define pb push_back
#define end1n " \n"[i == n]
#define endn1 " \n"[i == 1]
#define endl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef vector<vector<int>> vii;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
const int MAX = 2e18;
int h[N], e[N], w[N], ne[N], idx;
int f[N];
int n, q;
int res = 0;
void add(int a, int b, int c)
{
e[idx] = b;
w[idx] = c;
ne[idx] = h[a];
h[a] = idx++;
}
void dfs(int u, int fa)
{
for (int i = h[u]; i != -1; i = ne[i])
{
int v = e[i];
if (v != fa)
{
dfs(v, u);
f[u] = max(f[u], f[v] + w[i]);
}
}
for (int i = h[u]; i != -1; i = ne[i])
{
int v = e[i];
if (v != fa)
{
res += f[u] - (f[v] + w[i]);
}
}
}
// void dfs1(int u, int fa) {
// for(int i = h[u]; i != -1; i = ne[i]) {
// int v = e[i];
// if(v != fa) {
// dfs(v, u);
// res += f[u] - w[i];
// }
// }
// }
void solve()
{
cin >> n;
memset(h, -1, sizeof h);
int root;
cin >> root;
for (int i = 1; i <= n - 1; i++)
{
int a, b, c;
cin >> a >> b >> c;
add(a, b, c);
add(b, a, c);
}
dfs(root, -1);
cout << res << endl;
// cout << min(f[root][1], f[root][0]) << endl;
}
signed main()
{
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
// cin >> t;
t = 1;
while (t--)
{
solve();
}
return 0;
} | 这里是题目描述：# [ZJOI2007] 时态同步
## 题目描述
小 Q 在电子工艺实习课上学习焊接电路板。一块电路板由若干个元件组成，我们不妨称之为节点，并将其用数字 $1,2,3\cdots$ 进行标号。电路板的各个节点由若干不相交的导线相连接，且对于电路板的任何两个节点，都存在且仅存在一条通路（通路指连接两个元件的导线序列）。
在电路板上存在一个特殊的元件称为“激发器”。当激发器工作后，产生一个激励电流，通过导线传向每一个它所连接的节点。而中间节点接收到激励电流后，得到信息，并将该激励电流传向与它连接并且尚未接收到激励电流的节点。最终，激烈电流将到达一些“终止节点”――接收激励电流之后不再转发的节点。
激励电流在导线上的传播是需要花费时间的，对于每条边 $e$，激励电流通过它需要的时间为 $t_e$，而节点接收到激励电流后的转发可以认为是在瞬间完成的。现在这块电路板要求每一个“终止节点”同时得到激励电路――即保持时态同步。由于当前的构造并不符合时态同步的要求，故需要通过改变连接线的构造。目前小 Q 有一个道具，使用一次该道具，可以使得激励电流通过某条连接导线的时间增加一个单位。请问小 Q 最少使用多少次道具才可使得所有的“终止节点”时态同步？
## 输入格式
第一行包含一个正整数 $N$，表示电路板中节点的个数。
第二行包含一个整数 $S$，为该电路板的激发器的编号。
接下来 $N-1$ 行，每行三个整数 $a,b,t$。表示该条导线连接节点 $a$ 与节点 $b$，且激励电流通过这条导线需要 $t$ 个单位时间。
## 输出格式
仅包含一个整数 $V$，为小 Q 最少使用的道具次数。
## 样例 #1
### 样例输入 #1
```
3
1
1 2 1
1 3 3
```
### 样例输出 #1
```
2
```
## 提示
- 对于 $40\%$ 的数据，$1\le N\le 1000$。
- 对于 $100\%$ 的数据，$1\le N\le 5\times 10^5$。
对于所有的数据，$1\le t_e\le 10^6$。 下面是题目解析和做法：第一份题解：
题意让我们用最少的代价把叶子节点到根节点的距离调成相同
显然，我们调整靠近根节点的树枝，其下叶子节点距离根节点的距离都会增加，所以，**调整越靠根节点的树枝调整的代价越少**。
为了方便作图，效果直观，在此我们用**节点深度**类比**距离**
所以我们可以先找到最深的叶子节点
再从**最小的子树**开始，把所有子节点调整到**同一深度**，再调整子树上面的树枝
理解不了的话看这个图：
这样我们就可以保证用最少的代价把所有叶子节点调整到同一深度
我们理解了这个问题就可以设计dfs了
每次调整的代价都是$dis[x]-(dis[ver[i]+edge[i])$
把它累加即可
下面是详细代码
```
#include<bits/stdc++.h>
using namespace std;
const int N=500010;
int head[N],ver[N],next[N],tot,n,st,edge[N];
long long ans,dis[N];
void add(int x,int y,int z)//建图
{
ver[++tot]=y;
edge[tot]=z;
next[tot]=head[x];
head[x]=tot;
}
void dfs(int x,int fa)
{
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
dfs(y,x);//继续搜子树
dis[x]=max(dis[x],dis[y]+z);更新这棵子树根节点和叶子节点的最大距离
}
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
ans+=dis[x]-(dis[y]+z);//累加每次调整的代价
}
}
int main()
{
scanf("%d%d",&n,&st);
for(int i=1;i<n;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);add(y,x,z);//注意双向边
}
dfs(st,0);
printf("%lld",ans);
return 0;
}
```
第二份题解：
# 思路
看输入数据，由于n个节点只有n-1条边，不难看出这是一棵树。我们可以反着思考，就是让所有叶子节点同时发出信号，然后这些信号同时到达根节点。于是我们可以自下而上的进行维护，使得每一节点所有子节点的信号同时到达该节点。
于是我们考虑如何维护。我们从根节点开始搜索，搜索到叶子节点，回溯的时候进行维护，先维护节点的所有子节点到该节点最大边权（边权为**叶子**节点到同时到达它所需要时间）。然后维护答案，答案为最大边权减去所有到子节点的边权。然后维护父节点的边权，父节点边权为该节点子节点的 最大边权+父节点到该节点的时间。然后就回溯，重复操作，到根节点为止。~~好难说清楚啊QWQ 看注释更明白一点~~
然后我们要注意一些细节：
1. 一定要双向加边，是无向图。
2. 既然是无向图，维护时不要把到父节点的边计算了。
3. 维护的顺序一定不能乱。
4. 答案要用long long 存。
# 代码
```
#include <bits/stdc++.h >#define MAXN 1000005
using namespace std;
struct Edge{int next,to,dis;} edge[MAXN];
int n,s,a,b,t,maxn[MAXN],cnt,head[MAXN]; //maxn储存到子节点的最大边权
long long ans; //注意，答案要用long long 存
void addedge(int from, int to, int dis)
{
edge[++cnt].next=head[from];
edge[cnt].to=to;
edge[cnt].dis=dis;
head[from]=cnt;
} //前向星加边
void dfs(int x, int fa) //X为当前搜索节点，fa为x的父亲节点
{
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) dfs(edge[i].to, x);
//这一句一定要最先，先搜索到底层，回溯时再进行后续处理（从下向上维护）
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) maxn[x]=max(maxn[x], edge[i].dis);
//维护到子节点的最大边权
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) ans+=(maxn[x]-edge[i].dis);
//维护答案
for(int i=head[fa]; i; i=edge[i].next)
if(edge[i].to==x) edge[i].dis+=maxn[x];
//这一句不能漏，更新父节点到该节点的边权
}//注意顺序不能乱
int main()
{
scanf("%d%d ",&n,&s);
for(int i=1; i <=n-1; i++)
{
scanf("%d%d%d ",&a,&b,&t);
addedge(a, b, t);
addedge(b, a, t); //是无向图，双向加边
}
dfs(s, 0);
printf("%lld\n ",ans);
return 0;
}
``` 题目标签：树 形 动 态 规 划 | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define int long long
#define alls(x) x.begin(), x.end()
#define pb push_back
#define end1n " \n"[i == n]
#define endn1 " \n"[i == 1]
#define endl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef vector<vector<int>> vii;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
const int MAX = 2e18;
int h[N], e[N], w[N], ne[N], idx;
int f[N];
int n, q;
int res = 0;
void add(int a, int b, int c)
{
e[idx] = b;
w[idx] = c;
ne[idx] = h[a];
h[a] = idx++;
}
void dfs(int u, int fa)
{
for (int i = h[u]; i != -1; i = ne[i])
{
int v = e[i];
if (v != fa)
{
dfs(v, u);
f[u] = max(f[u], f[v] + w[i]);
}
}
}
void dfs1(int u, int fa)
{
for (int i = h[u]; i != -1; i = ne[i])
{
int v = e[i];
if (v != fa)
{
dfs(v, u);
res += f[u] - w[i];
}
}
}
void solve()
{
cin >> n;
memset(h, -1, sizeof h);
int root;
cin >> root;
for (int i = 1; i <= n - 1; i++)
{
int a, b, c;
cin >> a >> b >> c;
add(a, b, c);
add(b, a, c);
}
dfs(root, -1);
dfs1(root, -1);
cout << res << endl;
// cout << min(f[root][1], f[root][0]) << endl;
}
signed main()
{
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
// cin >> t;
t = 1;
while (t--)
{
solve();
}
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |
// Problem: P1131 [ZJOI2007] 时态同步
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1131
// Memory Limit: 512 MB
// Time Limit: 1000 ms
//
// Powered by CP Editor (https://cpeditor.org)
//
// author: sa_no_pool
// file: cpp
//
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define all(x) x.begin(), x.end()
#define stst stringstream
#define pb push_back
#define fa(i, op, n) for (int i = op; i <= n; i++)
#define fb(j, op, n) for (int j = op; j >= n; j--)
#define fg(i, op, n) for (int i = op; i != n; i = ne[i])
typedef long long LL;
typedef pair<LL, LL> PLL;
typedef pair<int, int> PII;
const int N = 1e6 + 10, INF = 0x3f3f3f3f, mod = 1e9 + 7;
int root, n;
int h[N], e[N * 2], ne[N * 2], idx, w[N * 2];
LL d[N];
LL ans = 0;
void add(int a, int b, int c)
{
e[++idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
void dfs(int u, int fa)
{
for (int i = h[u]; i; i = ne[i])
{
int v = e[i];
if (v == fa)
continue;
dfs(v, u);
d[u] = max(d[u], d[v] + w[i]);
}
for (int i = h[u]; i; i = ne[i])
{
int v = e[i];
if (v == fa)
continue;
ans += d[u] - (d[v] + w[i]);
}
}
int main()
{
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> root;
fa(i, 1, n - 1)
{
int a, b, w;
cin >> a >> b >> w;
add(a, b, w);
add(b, a, w);
}
dfs(root, 0);
cout << ans << endl;
return 0;
} | 这里是题目描述：# [ZJOI2007] 时态同步
## 题目描述
小 Q 在电子工艺实习课上学习焊接电路板。一块电路板由若干个元件组成，我们不妨称之为节点，并将其用数字 $1,2,3\cdots$ 进行标号。电路板的各个节点由若干不相交的导线相连接，且对于电路板的任何两个节点，都存在且仅存在一条通路（通路指连接两个元件的导线序列）。
在电路板上存在一个特殊的元件称为“激发器”。当激发器工作后，产生一个激励电流，通过导线传向每一个它所连接的节点。而中间节点接收到激励电流后，得到信息，并将该激励电流传向与它连接并且尚未接收到激励电流的节点。最终，激烈电流将到达一些“终止节点”――接收激励电流之后不再转发的节点。
激励电流在导线上的传播是需要花费时间的，对于每条边 $e$，激励电流通过它需要的时间为 $t_e$，而节点接收到激励电流后的转发可以认为是在瞬间完成的。现在这块电路板要求每一个“终止节点”同时得到激励电路――即保持时态同步。由于当前的构造并不符合时态同步的要求，故需要通过改变连接线的构造。目前小 Q 有一个道具，使用一次该道具，可以使得激励电流通过某条连接导线的时间增加一个单位。请问小 Q 最少使用多少次道具才可使得所有的“终止节点”时态同步？
## 输入格式
第一行包含一个正整数 $N$，表示电路板中节点的个数。
第二行包含一个整数 $S$，为该电路板的激发器的编号。
接下来 $N-1$ 行，每行三个整数 $a,b,t$。表示该条导线连接节点 $a$ 与节点 $b$，且激励电流通过这条导线需要 $t$ 个单位时间。
## 输出格式
仅包含一个整数 $V$，为小 Q 最少使用的道具次数。
## 样例 #1
### 样例输入 #1
```
3
1
1 2 1
1 3 3
```
### 样例输出 #1
```
2
```
## 提示
- 对于 $40\%$ 的数据，$1\le N\le 1000$。
- 对于 $100\%$ 的数据，$1\le N\le 5\times 10^5$。
对于所有的数据，$1\le t_e\le 10^6$。 下面是题目解析和做法：第一份题解：
题意让我们用最少的代价把叶子节点到根节点的距离调成相同
显然，我们调整靠近根节点的树枝，其下叶子节点距离根节点的距离都会增加，所以，**调整越靠根节点的树枝调整的代价越少**。
为了方便作图，效果直观，在此我们用**节点深度**类比**距离**
所以我们可以先找到最深的叶子节点
再从**最小的子树**开始，把所有子节点调整到**同一深度**，再调整子树上面的树枝
理解不了的话看这个图：
这样我们就可以保证用最少的代价把所有叶子节点调整到同一深度
我们理解了这个问题就可以设计dfs了
每次调整的代价都是$dis[x]-(dis[ver[i]+edge[i])$
把它累加即可
下面是详细代码
```
#include<bits/stdc++.h>
using namespace std;
const int N=500010;
int head[N],ver[N],next[N],tot,n,st,edge[N];
long long ans,dis[N];
void add(int x,int y,int z)//建图
{
ver[++tot]=y;
edge[tot]=z;
next[tot]=head[x];
head[x]=tot;
}
void dfs(int x,int fa)
{
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
dfs(y,x);//继续搜子树
dis[x]=max(dis[x],dis[y]+z);更新这棵子树根节点和叶子节点的最大距离
}
for(int i=head[x];i;i=next[i])
{
int y=ver[i],z=edge[i];
if(y==fa) continue;
ans+=dis[x]-(dis[y]+z);//累加每次调整的代价
}
}
int main()
{
scanf("%d%d",&n,&st);
for(int i=1;i<n;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);add(y,x,z);//注意双向边
}
dfs(st,0);
printf("%lld",ans);
return 0;
}
```
第二份题解：
# 思路
看输入数据，由于n个节点只有n-1条边，不难看出这是一棵树。我们可以反着思考，就是让所有叶子节点同时发出信号，然后这些信号同时到达根节点。于是我们可以自下而上的进行维护，使得每一节点所有子节点的信号同时到达该节点。
于是我们考虑如何维护。我们从根节点开始搜索，搜索到叶子节点，回溯的时候进行维护，先维护节点的所有子节点到该节点最大边权（边权为**叶子**节点到同时到达它所需要时间）。然后维护答案，答案为最大边权减去所有到子节点的边权。然后维护父节点的边权，父节点边权为该节点子节点的 最大边权+父节点到该节点的时间。然后就回溯，重复操作，到根节点为止。~~好难说清楚啊QWQ 看注释更明白一点~~
然后我们要注意一些细节：
1. 一定要双向加边，是无向图。
2. 既然是无向图，维护时不要把到父节点的边计算了。
3. 维护的顺序一定不能乱。
4. 答案要用long long 存。
# 代码
```
#include <bits/stdc++.h >#define MAXN 1000005
using namespace std;
struct Edge{int next,to,dis;} edge[MAXN];
int n,s,a,b,t,maxn[MAXN],cnt,head[MAXN]; //maxn储存到子节点的最大边权
long long ans; //注意，答案要用long long 存
void addedge(int from, int to, int dis)
{
edge[++cnt].next=head[from];
edge[cnt].to=to;
edge[cnt].dis=dis;
head[from]=cnt;
} //前向星加边
void dfs(int x, int fa) //X为当前搜索节点，fa为x的父亲节点
{
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) dfs(edge[i].to, x);
//这一句一定要最先，先搜索到底层，回溯时再进行后续处理（从下向上维护）
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) maxn[x]=max(maxn[x], edge[i].dis);
//维护到子节点的最大边权
for(int i=head[x]; i; i=edge[i].next)
if(edge[i].to!=fa) ans+=(maxn[x]-edge[i].dis);
//维护答案
for(int i=head[fa]; i; i=edge[i].next)
if(edge[i].to==x) edge[i].dis+=maxn[x];
//这一句不能漏，更新父节点到该节点的边权
}//注意顺序不能乱
int main()
{
scanf("%d%d ",&n,&s);
for(int i=1; i <=n-1; i++)
{
scanf("%d%d%d ",&a,&b,&t);
addedge(a, b, t);
addedge(b, a, t); //是无向图，双向加边
}
dfs(s, 0);
printf("%lld\n ",ans);
return 0;
}
``` 题目标签：树 形 动 态 规 划 | // Problem: P1131 [ZJOI2007] 时态同步
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1131
// Memory Limit: 512 MB
// Time Limit: 1000 ms
//
// Powered by CP Editor (https://cpeditor.org)
//
// author: sa_no_pool
// file: cpp
//
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define all(x) x.begin(), x.end()
#define stst stringstream
#define pb push_back
#define fa(i, op, n) for (int i = op; i <= n; i++)
#define fb(j, op, n) for (int j = op; j >= n; j--)
#define fg(i, op, n) for (int i = op; i != n; i = ne[i])
typedef long long LL;
typedef pair<LL, LL> PLL;
typedef pair<int, int> PII;
const int N = 1e6 + 10, INF = 0x3f3f3f3f, mod = 1e9 + 7;
int root, n;
int h[N], e[N], ne[N], idx, w[N];
int d[N];
int mx = 0;
int ans = 0;
void add(int a, int b, int c)
{
e[++idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
void dfs(int u, int fa)
{
for (int i = h[u]; i; i = ne[i])
{
int v = e[i];
if (v == fa)
continue;
dfs(v, u);
d[u] = max(d[u], d[v] + w[i]);
}
for (int i = h[u]; i; i = ne[i])
{
int v = e[i];
if (v == fa)
continue;
ans += d[u] - (d[v] + w[i]);
}
}
int main()
{
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> root;
fa(i, 1, n - 1)
{
int a, b, w;
cin >> a >> b >> w;
add(a, b, w);
add(b, a, w);
}
dfs(root, 0);
cout << ans << endl;
return 0;
} | 为我指出下面代码的问题，并修复它。下面是题目描述和题解 |