2021 Xinjiang Provincial Collegiate Programming Contest

G cocktail with snake
大致题意：在n * m的点阵里，点A从(1, 1)出发，沿题意所示的方向进行弓形走位(就是遇到边界就会向上拐弯)，问走到第k步时的曼哈顿距离

分析：这类题的难点是判断当前的位置是往右边界去还是从右边界回来(分奇偶）

注意到向上这一段距离也可等效于（看成）水平方向上从x = 0 ~ x = 1 这一段因此，当再次回到 x = 1直线上时为一个周期，此时恰好水平方向上一个来回，走了两个拐弯，此时d = 2 * n

所以通过判断 k % n的值进行分类讨论即可，而k / n 表示走了多少个半个周期, 而且表示竖直方向上走过的距离，k % n贡献水平方向上的距离，在回来时贡献为- k % n
即可解决

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

signed main()
{
    int t;
    cin >> t;

    while (t --)
    {
        int ans = 0;
        int n , m , k;
        cin >> n >> m >> k;

        if (((k / n) % 2) == 0)
        {
            ans += (k / n) + (k % n);
        }

        else
        {
            ans += (k / n) + (n - k % n - 1);
        }

        cout << ans << endl;
    }
    
    return 0;
}

j do NOT a=2b
思路：
动态规划

一种略麻烦的写法是先预处理出每一条链，然后对链做DP。

但是实际上因为值域只有1e6，所以只对值域做一个DP即可。

然后对于所有i*2>1e6的数字计算答案即可

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<assert.h>
using namespace std;
#define ll long long
const int maxn = 1e6+10;
int n;
int a[maxn],dp[maxn][2];
int ans;
int main()
{
    scanf("%d",&n);
    int x;
    while(n--)
    {
        scanf("%d",&x);
        a[x]++;
    }
    
    for(int i=1;i<=1000000;i++)
    {
        if(i%2==0)//如果i是偶数
        {
            dp[i][1]=dp[i/2][0];//如果这个数不删除 那么前一个数必须要删除 且删除的数量等于前一个数
            dp[i][0]=min(dp[i/2][0],dp[i/2][1])+a[i];
            //如果删除这个数字 则取前一个数的较小数并且加上这个数要删除的数量
        }
        else//如果是奇数
        {
            dp[i][0]=a[i];//删掉
            dp[i][1]=0;//不删
        }
    }
        
    for(int i=1;i<=1000000;i++)
    {
        if(i*2>1000000)ans+=min(dp[i][0],dp[i][1]);
    }
    printf("%d",ans);
    return 0;
}

K.chino with c language（签到）``

题意
memcpy不检查源地址和目标地址是否有重叠
memmove考虑重叠的情况

思路：
直接写

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

const int maxn = 1e5+10;

char s[maxn], t[maxn];
void solve()
{
    int n,l,p1,p2;
    cin >> n >> s + 1 >> p1 >> p2 >> l;
    memcpy(t + 1, s + 1, n * sizeof(char));
    memmove(t + p2, t + p1, l * sizeof(char));
    for (int i = 0; i < l; ++i) s[p2 + i] = s[p1 + i];
    cout << s + 1;
    cout << endl;
    cout <<t + 1;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);
        solve();
    return 0;
}