AtCoder Beginner Contest 210

D – National Railway

题目描述：

给你一个矩阵，每个点都有一个权值，如果这个点被选择，则需要付出他的权值，你需要选择两个不同的点(任意选)，在这两个点之间建一条边，边的花费是两点的曼哈顿距离乘以c，问点权和边权和最小是多少

思路：

这个题是一个非常非常妙的dp,abc的dp真的会给人眼前一亮的感觉

显然，最暴力方法是 $O(n^4)$，也就是暴力枚举两个点计算最小答案，但这毫无疑问会TLE，所以我们可以考虑进行优化

因为曼哈顿距离是|x1 - x2| + |y1 - y2|,存在绝对值的限制，我们可以规定(x1, y1)在(x2, y2)的左上角，也就是满足x2>=x1, y2 >= y1,这样选择任意两个点的总权值就是：

$a[x1][y1] + a[x2][y2] + c * (x2-x1)+c*(y2-y1)$,

再调整一下顺序:

$a[x1][y1]-c*(x1+y1)+a[x2][y2]+c*(x2+y2)$

我们可以通过枚举(x2, y2)来获得a[x2][y2]+c*(x2 + y2)的值，现在需要知道(1, 1)到(x2, y2)中最小的a[i][j]-c*(i+j),这个可以用dp来维护

我们可以用$dp[x][y]$来表示(1,1)到(i, j)中最小的a[i][j]-c*(i+j)

因为当前是假定从左上到右下，所以状态转移方程是：

dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]);
dp[i][j] = min(dp[i][j], a[i][j] - c * (i + j));

还需要注意的是，选择的点是不同的，所以应该先计算(i, j)的贡献，再更新选(i, j)时的最小权值，即：dp[i][j] = min(dp[i][j], a[i][j] - c * (i + j));

所以dp里面应该这么写

dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]);
ans = min(ans, dp[i][j] + tr[i][j] + c * i + c * j);
dp[i][j] = min(dp[i][j], tr[i][j] - c * i - c * j);

因为我们假的是左上到右下，还可能是右上到左上，所以还需要再来一次类似的

需要注意，此时去掉绝对值和上次不一样了，即x2>=x1, y2<=y1，所以是：

$a[x_1][y_1]+a[x_2][y_2]+(x_2-x_1)*c+(y_1-y_2)*c$

同样的，同类放在一起

$a[x_1][y_1]-x_1*c+y_1*c+a[x_2][y_2]+x_2*c-y_2*c$

dp维护的值也发生了改变，状态转移方程应该这么写

dp[i][j] = min(dp[i - 1][j], dp[i][j + 1]);
ans = min(ans, dp[i][j] + tr[i][j] + c * i - c * j);
dp[i][j] = min(dp[i][j], tr[i][j] - c * i + c * j);

每次dp前都需要给数组赋初值为无穷大

#include <bits/stdc++.h>
using namespace std;

#define endl '\n'
#define inf 0x3f3f3f3f
#define mod7 1000000007
#define mod9 998244353
#define m_p(a,b) make_pair(a, b)
#define mem(a,b) memset((a),(b),sizeof(a))
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define debug(a) cout << "Debuging...|" << #a << ": " << a << "\n";
typedef long long ll;
typedef pair <int,int> pii;

#define MAX 300000 + 50
int n, m;
ll c;
ll tr[1005][1005];
ll dp[1005][1005];
void work(){
    cin >> n >> m >> c;
    for(int i = 1; i <= n; ++i){
        for(int j = 1; j <= m; ++j){
            cin >> tr[i][j];
        }
    }
    ll ans = 1e18;
    mem(dp, 0x3f);
    for(int i = 1; i <= n; ++i){
        for(int j = 1; j <= m; ++j){
            dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]);
            ans = min(ans, dp[i][j] + tr[i][j] + c * i + c * j);
            dp[i][j] = min(dp[i][j], tr[i][j] - c * i - c * j);
        }
    }
    mem(dp, 0x3f);
    for(int i = 1; i <= n; ++i){
        for(int j = m; j >= 1; --j){
            dp[i][j] = min(dp[i - 1][j], dp[i][j + 1]);
            ans = min(ans, dp[i][j] + tr[i][j] + c * i - c * j);
            dp[i][j] = min(dp[i][j], tr[i][j] - c * i + c * j);
        }
    }
    cout << ans << endl;
}


int main(){
    io;
    work();
    return 0;
}

E – Ring MST

题目描述：

n个点，m种操作，每种操作都有一个a, c,即你可以选择任意一个点x和(x+a)%n连一条长度为c的边,每种操作都可以进行任意次，顺序也可以任意，问把n个点连成一个连通图的最小权值是多少

思路：

显然是一个最小生成树的题，但是克鲁斯卡尔的复杂度是O(mlongm)，这里的m指的是边的数量，也就是点的数量减1，即n-1，这个题的n<=1e9，显然不能做，所以我们考加速克鲁斯卡尔的过程，克鲁斯卡尔的过程无非是对边排序，然后判断是否在一个连通块，然后连边，而题这里我们把m种操作看成m种边，每种边可能会连很多个不同的点，也就会导致合并巨慢。

我们考虑每种连边方式能连接的边的数量是：使用该方法后的连通块的数量 – 使用该方法前的连通块的数量。

那问题又来了，怎么计算使用该边后的连通块的数量？

官方题解写的非常非常好，难得我能看懂一次官方题解

如果u和v可以通过前t条边相连，也就是存在一组解 $(k_1,k_2...k_t)$ 满足：$v ≡ u + k_1A_1+k_2A_2+...+k_tA_t(mod\space n)$

也就是存在一组解 $(k_0,k_1,k_2...k_t)$，满足：

$v = u + k_0*n + k_1A_1+k_2A_2+...+k_tA_t$

我们令 $d = gcd(n,A_1,A_2...A_t)$

则$v = u + k*d$

即 $v ≡ u (mod\space d)$

也就是存在d个连通块

所以我们可以对边的权值从小到大排序，然后用一个变量记录当前剩余的连通块的数量，再求gcd(n, a1, a2...ai)，二者相减就得到该边用的次数，乘上权值就行

#include <bits/stdc++.h>
using namespace std;

#define endl '\n'
#define inf 0x3f3f3f3f
#define mod7 1000000007
#define mod9 998244353
#define m_p(a,b) make_pair(a, b)
#define mem(a,b) memset((a),(b),sizeof(a))
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define debug(a) cout << "Debuging...|" << #a << ": " << a << "\n";
typedef long long ll;
#define int long long
typedef pair <int,int> pii;

#define MAX 300000 + 50
int n, m, k, x;
struct ran{
    int a, c;
    bool operator < (const ran &x)const{
        return c < x.c;
    }
}tr[MAX];

int gcd(int a, int b){
    if(!b)return a;
    else return gcd(b, a % b);
}

void work(){
    cin >> n >> m;
    for(int i = 1; i <= m; ++i)cin >> tr[i].a >> tr[i].c;
    sort(tr + 1, tr + 1 + m);
    ll ans = 0;
    int sum = n;
    int gg = n;
    for(int i = 1; i <= m; ++i){
        gg = gcd(gg, tr[i].a);
        ans += (sum - gg) * tr[i].c;
        sum = gg;
        if(gg == 1)break;
    }
    if(gg == 1)cout << ans << endl;
    else cout << -1 << endl;
}

signed main(){
    io;
    work();
    return 0;
}