AtCoder Beginner Contest 232(A-G)

最新推荐文章于 2024-07-19 19:11:19 发布

A real Warrior

最新推荐文章于 2024-07-19 19:11:19 发布

阅读量143

点赞数

分类专栏： Atcoder 思维题图论文章标签：算法图论动态规划

kkk

本文链接：https://blog.csdn.net/scanner___yw/article/details/133584303

版权

思维题同时被 3 个专栏收录

25 篇文章 0 订阅

订阅专栏

Atcoder

22 篇文章 1 订阅

订阅专栏

图论

10 篇文章 0 订阅

订阅专栏

A - QQ solver (atcoder.jp)直接按题意模拟即可。

B - Caesar Cipher (atcoder.jp)按题意模拟即可

C - Graph Isomorphism (atcoder.jp)按题意模拟即可

D - Weak Takahashi (atcoder.jp) 一个非常套路的网格dp

E - Rook Path (atcoder.jp)

（1）题意

有一个H*W的网格，网格中有一个车初始在(x1,y1)这个位置，高桥操作K次后达到(x2,y2)的方案数是多少，每一次移动可以挪到一行或者这一列的任意一个位置上去，但是不能在原始位置。

（2）思路

考虑K不大，我们进行O(K)的dp。

定义dp[i][0]表示前i步操作操作完后和最终位置行列都不同的方案数

定义dp[i][1]表示前i步操作操作完后和最终位置列相同的方案数

定义dp[i][2]表示前i步操作操作完后和最终位置列相同的方案数

定义dp[i][3]表示前i步操作操作完后和最终位置行列都相同的方案数

1.首先若第i步操作想要变成行列都相同，则前(i - 1)步一定是行相同或者列相同

$dp[i][3] = dp[i - 1][2] + dp[i - 1][1]$

2.若第i步操作只要变成行相同，那么前面可能是通过行相同，但第i步走到了不同列，或者是前面i-1步行列都不同走到这行上来了，或者是前面行列都一样，走到不同的列去了。

$dp[i][2] = dp[i - 1][2] * (w - 2) + dp[i - 1][0] + dp[i - 1][3] * (w - 1)$

3.若第i步操作只要变成列相同，那么前面可能是通过列相同，但第i步走到了不同行，或者是前面i-1步行列都不同走到这列上来了，或者是前面行列都一样，走到不同的行去了。

$dp[i][1] = dp[i - 1][1] * (h - 2) + dp[i - 1][0] + dp[i - 1][3] * (h - 1)$

4.若第i步操作想要变成行列都不同，那么可能是通过行相同，然后走到了不同行，或者是列相同走到了不同列，或者是行列都不同又走到了行列都不同。

$dp[i][0] = dp[i - 1][2] * (h - 1) + dp[i - 1][1] * (w - 1) + dp[i - 1][0] * (w - 2) + dp[i - 1][0] * (h - 2)$

（3）代码

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 1e6 + 10;
ll dp[N][4];
const ll mod = 998244353;
void solve()
{
    ll h,w,k;
    cin >> h >> w >> k;
    int x1,y1,x2,y2;
    cin >> x1 >> y1 >> x2 >> y2;
    if(x1 == x2 && y1 == y2) dp[0][3] = 1;
    else if(x1 == x2) dp[0][2] = 1;
    else if(y1 == y2) dp[0][1] = 1;
    else dp[0][0] = 1;
    //3 :行列都相同，2：行相同 1：列相同 0：行列都不同
    rep(i,1,k) {
        dp[i][3] = dp[i - 1][2] + dp[i - 1][1];
        dp[i][2] = dp[i - 1][2] * (w - 2) % mod + dp[i - 1][0] + dp[i - 1][3] * (w - 1) % mod;
        dp[i][1] = dp[i - 1][1] * (h - 2) % mod + dp[i - 1][0] + dp[i - 1][3] * (h - 1) % mod;
        dp[i][0] = dp[i - 1][2] * (h - 1) % mod + dp[i - 1][1] * (w - 1) + dp[i - 1][0] * (w - 2) % mod + dp[i - 1][0] * (h - 2) % mod;
        rep(j,0,3) dp[i][j] %= mod;
    }
    cout << dp[k][3];
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    // cin >> T;
    while(T --) solve();
    return 0;
}

F - Simple Operations on Sequence (atcoder.jp)

（1）题意

给你一个长度为N的A序列和一个长度为N的B序列，你每次可以对A的一个元素进行加1或减1，这个操作一次花费X元，你也可以对A的一个元素i进行交换，交换A[i]和A[i + 1]，这个操作花费Y元，问你使得A序列变成B序列的最小花费是多少？

（2）思路

考虑N不大，我们直接进行状压dp，dp[i]表示i这个点集我已经匹配了多少个A序列的位置，匹配了B的哪些位置需要的最小花费。

那么考虑转移首先枚举我要放的位置（也就是A未匹配的位置），我们把A[j]这个元素放到z这个位置上去，考虑前面已经放了met个，那么你一定需要交换met次。

最终输出dp[(1 << N) - 1]即可。

（3）代码

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 20;
ll dp[1 << N];
int a[N],b[N];
void solve()
{
    ll n,X,Y;
    cin >> n >> X >> Y;
    rep(i,0,n - 1) cin >> a[i];
    rep(i,0,n - 1) cin >> b[i];
    memset(dp,0x3f,sizeof(dp));
    dp[0] = 0;
    for(int i = 0;i < (1 << n);i ++) {
        int z = __builtin_popcount(i),met = 0;
        for(int j = n - 1;j >= 0;j --) {
            if(!(i >> j & 1)) {
                dp[i | (1 << j)] = min(dp[i | 1 << j],dp[i] + 1ll * abs(a[j] - b[z]) * X + 1ll * met * Y);
            }
            else met ++;
        }
    }
    cout << dp[(1 << n) - 1];
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    // cin >> T;
    while(T --) solve();
    return 0;
}

G - Modulo Shortest Path (atcoder.jp)

（1）题意

给你两个序列A和B，你有一条从i->j的权值为(A[i] + B[j]) % M的边，问你从1走到N的最短路径是多长。

（2）思路

考虑暴力，我们建边都要N^2，显然不可行，考虑优化建边。

对于A序列我们把i向M - A[i]连一条权值为0的边，对于B序列我们把B[i]向i连一条权值为0的边，对于[0,M - 1]把0->1,1->2.....M - 2->M - 1连一条权值为1的边，这样图就变成了这样。

为什么要向M-A[i]连边而不是向A[i]连边呢？我们考虑分类讨论一下，画一下横坐标就行了。

好，现在我们的建边从N^2变成了2*N+M,显然M太大过不了，那么考虑其实有些边是用不到的，比如说0-1->2->3->4->5，难道我真要一步步跳过去？显然不可能，我们可以直接压缩成0->5。那哪些模数要用到呢，实际上就是我们建边用的M - a[i]和b[i],从小的向大的连一下即可，然后跑一个最短路就做完了。

（3）代码

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 6e5 + 10;
vector<PII> e[N];
int a[N],b[N];
ll dis[N];
vector<int> ver;
int get(int x)
{
    return lower_bound(all(ver),x) - ver.begin() + 1;
}
inline ll dij(int s,int t)
{
    memset(dis,0x3f,sizeof(dis));
    dis[s] = 0;
    priority_queue<pair<ll,int>,vector<pair<ll,int>>,greater<pair<ll,int>>> q;
    q.push({dis[s],s});
    while(!q.empty()) {
        auto [val,u] = q.top();
        q.pop();
        for(auto [v,w]: e[u]) {
            if(dis[v] > val + w) {
                dis[v] = val + w;
                q.push({dis[v],v});
            }
        }
    }
    return dis[t];
}
void solve()
{
    int n,m;
    cin >> n >> m;
    rep(i,1,n) {
        cin >> a[i];
        a[i] = (m - a[i]) % m;
        ver.pb(a[i]);
    }
    rep(i,1,n) {
        cin >> b[i];
        ver.pb(b[i]);
    }
    sort(all(ver));
    rep(i,1,n) {
        a[i] = get(a[i]);
        b[i] = get(b[i]);
        e[i + sz(ver)].pb({a[i],0});
        e[b[i]].pb({i + sz(ver),0});
    }
    rep(i,1,sz(ver) - 1) {
        e[i].pb({i + 1,ver[i] - ver[i - 1]});
    }
    e[sz(ver)].pb({1,(ver[0] -ver[sz(ver) - 1] + m) % m});
    cout << dij(1 + sz(ver),n + sz(ver));
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    // cin >> T;
    while(T --) solve();
    return 0;
}

A real Warrior

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
AtCoder Beginner Contest 232(A-G)

给你一个长度为N的A序列和一个长度为N的B序列，你每次可以对A的一个元素进行加1或减1，这个操作一次花费X元，你也可以对A的一个元素i进行交换，交换A[i]和A[i + 1]，这个操作花费Y元，问你使得A序列变成B序列的最小花费是多少？对于A序列我们把i向M - A[i]连一条权值为0的边，对于B序列我们把B[i]向i连一条权值为0的边，对于[0,M - 1]把0->1,1->2.....M - 2->M - 1连一条权值为1的边，这样图就变成了这样。为什么要向M-A[i]连边而不是向A[i]连边呢？
复制链接

扫一扫