Codeforces Round #264 (Div. 2)

最新推荐文章于 2025-07-28 11:16:14 发布

原创最新推荐文章于 2025-07-28 11:16:14 发布 · 755 阅读

0 ·

CC 4.0 BY-SA版权

Codeforces 专栏收录该内容

15 篇文章

订阅专栏

题目： LINK

A。水题，不多说。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <queue>
#include <map>
#include <set>
using namespace std; 
#define INF 1000000000
//typedef __int64 LL; 
int n, s; 
int x, y; 
int main() 
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin); 
#endif 
    scanf("%d%d", &n, &s); 
    int ans = -INF; 
    for(int i = 1; i <= n; i++) {
        scanf("%d%d", &x, &y); 
        if(x > s) continue; 
        if(x == s && y) continue; 
        if(y == 0) ans = max(ans, 0); 
        else ans = max(ans, 100 - y); 
    }
    if(ans < 0) printf("-1\n"); 
    else printf("%d\n", ans); 
    
    return 0; 
}

B。遍历一遍，就可以了.

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <queue>
#include <map>
#include <set>
using namespace std; 
#define INF 1000000000
//typedef __int64 LL; 
#define N 100005
int hh[N], n; 
int main() 
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin); 
#endif // ONLINE_JUDGE
    scanf("%d", &n); 
    hh[0] = 0; 
    for(int i = 1; i<=n; i++) {
        scanf("%d", &hh[i]); 
    }
    int ans = 0; 
    int now = 0; 
    for(int i = 1; i<=n; i++){
        if(hh[i-1] >= hh[i]) {
            now += hh[i-1] - hh[i]; 
        }
        else {
            int tmp = hh[i] - hh[i-1]; 
            if(now >= tmp) {
                now -= tmp; 
            }
            else {
                ans += tmp - now; 
                now = 0; 
            }
        }
    }
    printf("%d\n", ans); 
    return 0; 
}

C. 可以看成DP吧，其实就是预处理出来每个点四个方向过来的总和。每个点的和为四个方向加起来

如果两个点，满足条件等价于两点的横坐标之差，和纵坐标之差，有且仅有一个为奇数.

按照坐标的奇偶可以分为四类点，处理出来每一类的最值，和最值的坐标。之后在满足条件的点的组合中取最大值就可以了. 注意这组数据就可以了

0 0

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <queue>
#include <map>
#include <set>
using namespace std;
#define INF 1000000000
typedef __int64 LL;
#define N 2005
LL n;
LL num[N][N], dp1[N][N], dp2[N][N], dp3[N][N], dp4[N][N], dp[N][N];
LL ma[10];
struct node {
    int x, y;
}gg[10];
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
    scanf("%I64d", &n);
    for(LL i = 1; i<=n; i++) {
        for(int j = 1; j <= n; j++) {
            scanf("%I64d", &num[i][j]);
        }
    }
    for(int i = 1; i<=n; i++) {
        for(int j = 1; j<=n; j++) {
            dp1[i][j] = dp1[i-1][j-1] + num[i][j];
        }
    }
    for(int i = 1; i<=n; i++) {
        for(int j = n; j>=1; j--) {
            dp2[i][j] = dp2[i-1][j+1] + num[i][j];
        }
    }
    for(int i = n; i>=1; i--) {
        for(int j = 1; j<=n; j++) {
            dp3[i][j] = dp3[i+1][j-1] + num[i][j];
        }
    }
    for(int i = n; i>=1; i--) {
        for(int j = n; j>=1; j--) {
            dp4[i][j] = dp4[i+1][j+1] + num[i][j];
        }
    }
    for(int i = 1; i<=n; i++) {
        for(int j = 1; j<= n; j++) {
            dp[i][j] = dp1[i][j] + dp2[i][j] + dp3[i][j] + dp4[i][j] - num[i][j] * 3;
            int ii = i&1;
            int jj = j&1;
            int s = (ii<<1) | jj;
            if(dp[i][j] >= ma[s]) {
                ma[s] = dp[i][j]; gg[s].x = i; gg[s].y = j;
            }
        }
    }
    LL ans = 0;
    int x1, y1, x2, y2;
    if(ma[0] + ma[1] >=ans) {
        ans = ma[0] + ma[1]; x1 = gg[0].x; y1 = gg[0].y;
        x2 = gg[1].x; y2 = gg[1].y;
    }
    if(ma[0] + ma[2] >= ans) {
        ans = ma[0] + ma[2]; x1 = gg[0].x; y1 = gg[0].y;
        x2 = gg[2].x; y2 = gg[2].y;
    }
    if(ma[3] + ma[1] >=ans) {
        ans = ma[3] + ma[1]; x1 = gg[3].x; y1 = gg[3].y;
        x2 = gg[1].x; y2 = gg[1].y;
    }
    if(ma[3] + ma[2] >=ans) {
        ans = ma[3] + ma[2]; x1 = gg[3].x; y1 = gg[3].y;
        x2 = gg[2].x; y2 = gg[2].y;
    }
    printf("%I64d\n", ans);
    printf("%d %d %d %d\n", x1, y1, x2, y2) ;
    return 0;
}

D. 给你k个长度为n的1~n的排列,求这k个的最长公共子序列. 发现 k 很小, 而且序列是n的排列, 注意这两个条件.
dp[i] 表示以第一个序列为参考，以第i个位置为终点的LCS的长度.
dp[i] = dp[j] + 1 ,if 第一个序列中num[j] num[i] (j<i)在所有序列中都满足num[i] 在 num[j]前面.
结果ans = max(dp[1~n]);

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
using namespace std; 
#define INF 1000000000
#define N 7 
#define M 1010
int a[N][M], b[N][M], n, k, dp[M]; 
int main() 
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin); 
#endif 
    scanf("%d%d", &n, &k); 
    int tmp ; 
    for(int i = 1; i <= k; i++) {
        for(int j = 1; j<= n; j++) {
            scanf("%d", &tmp); a[i][j] = tmp; b[i][tmp] = j; 
        }
    }
    int ans = 0; 
    for(int i = 1; i <= n; i++) {
        dp[i] = 1; 
        for(int j = 1; j < i ; j++) {
            int flag = 0; 
            for(int ii = 2; ii <= k; ii ++) {
                if(b[ii][a[1][i]] < b[ii][a[1][j]]) flag = 1; 
                if(flag) continue;
            }
            if(flag) continue; 
            dp[i] = max(dp[j]+1, dp[i]); 
        }
        ans = max(ans, dp[i]); 
    }
    printf("%d\n", ans); 
    return 0; 
}

E. 给你n(1e5)个节点的有根数(1 is root) ,每个点有一个值，1e5个操作,第一种操作，求从根1到给定点v的路径上的满足gcd(val[v], val[xi]),xi是路径上的点，输出xi，如果有多个输出距离v最近的一个, 没有输出-1 .第二种操作是把某点的权值更改为一个新值.
第二种操作不会超过50.
CF测评机本来跑的就很快而且给了10s，直接裸着搞。
先遍历有根树，记录每个点的父亲，之后对于每个询问直接往上找就可以了。还有其他优美的解法？

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <queue>
#include <map>
#include <set>
using namespace std;
#define INF 1000000000
//typedef __int64 LL;
#define N 100010
int hh[N], tot, n, q, val[N], par[N];
struct node {
    int u, v, next;
}edge[700000];
void init() {
    memset(hh, -1, sizeof(hh));
    tot = 0;
}
void add(int u, int v) {
    edge[tot].v = v; edge[tot].next = hh[u];
    hh[u] = tot ++;
}
int gcd(int x, int y) {
    if(!y) return x ;
    return gcd(y, x%y);
}
void dfs(int u, int last) {
    for(int i = hh[u]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(v == last) continue;
        par[v] = u;
        dfs(v, u);
    }
}
void sol(int u) {
    int tmp = par[u];
    int vv = val[u];
    while(tmp != 0) {
        if(gcd(val[tmp], vv) != 1) {
            printf("%d\n", tmp);    return ; 
        }
        tmp = par[tmp];
    }
    puts("-1");
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
    scanf("%d%d", &n, &q);
    for(int i = 1; i <= n ;i++)  scanf("%d", &val[i]); 
    init();
    int u, v;
    for(int i = 1; i < n; i++) {
        scanf("%d%d", &u, &v);
        add(u, v); add(v, u);
    }
    dfs(1, -1);
    while(q-- ) {
        int x, y, z;
        scanf("%d%d", &x, &y);
        if(x == 1) {
            sol(y);
        }
        else {
            scanf("%d", &z);
            val[y] = z;
        }
    }
    return 0;
}