【AtCoder】AGC021

最新推荐文章于 2021-05-23 18:11:33 发布
最新推荐文章于 2021-05-23 18:11:33 发布
阅读量199 收藏
点赞数
原文链接：http://www.cnblogs.com/ivorysi/p/9960176.html
版权

A - Digit Sum 2

从高位到低位数的第i位以前前缀都相同，第i位比当前位上的数小1的情况下，后面都填9
枚举一下然后计算最大的就好

#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define enter putchar('\n')
#define space putchar(' ')
#define MAXN 100005
//#define ivorysi
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;char c = getchar();T f = 1;
    while(c < '0' || c > '9') {
    if(c == '-') f = -1;
    c = getchar();
    }
    while(c >= '0' && c <= '9') {
    res = res * 10 + c - '0';
    c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) {
    out(x / 10);
    }
    putchar('0' + x % 10);
}
int64 N;
int x[25],tot;
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    read(N);
    while(N) {
    x[++tot] = N % 10;
    N /= 10;
    }
    int ans = 0,sum = 0;
    for(int i = tot ; i >= 1 ; --i) {
    ans = max(ans,sum + x[i] - 1 + (i - 1) * 9);
    sum += x[i];
    }
    ans = max(ans,sum);
    out(ans);enter;
    return 0;
}

B - Holes

如果两个点的话或者所有点共线的话两个端点各是0.5
我们给这些点求一个凸包，由于半径是无穷大，我们只关心凸包上的点相邻两边做垂直平分线交出来的角除以2PI的值
这个值可以用PI减去凸包上的顶角求出来

#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define enter putchar('\n')
#define space putchar(' ')
#define MAXN 100005
#define eps 1e-8
//#define ivorysi
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;char c = getchar();T f = 1;
    while(c < '0' || c > '9') {
    if(c == '-') f = -1;
    c = getchar();
    }
    while(c >= '0' && c <= '9') {
    res = res * 10 + c - '0';
    c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) {
    out(x / 10);
    }
    putchar('0' + x % 10);
}
const db PI = acos(-1.0);
int N,top;
db ans[105];
bool dcmp(db a,db b) {
    return fabs(b - a) <= eps;
}
struct Point {
    db x,y;int id;
    Point(db _x = 0.0,db _y = 0.0) {
    x = _x;y = _y;
    }
    friend Point operator + (const Point &a,const Point &b) {
    return Point(a.x + b.x,a.y + b.y);
    }
    friend Point operator - (const Point &a,const Point &b) {
    return Point(a.x - b.x,a.y - b.y);
    }
    friend Point operator * (const Point &a,const db &d) {
    return Point(a.x * d,a.y * d);
    }
    friend db operator * (const Point &a,const Point &b) {
    return a.x * b.y - a.y * b.x;
    }
    friend db dot(const Point &a,const Point &b) {
    return a.x * b.x + a.y * b.y;
    }
    db norm() {
    return sqrt(x * x + y * y);
    }
}P[105],sta[105];

bool cmp(Point a,Point b) {
    db d = (a - P[1]) * (b - P[1]);
    if(dcmp(d,0.0)) {return (a - P[1]).norm() < (b - P[1]).norm();}
    else return d > 0;
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    int x,y;
    read(N);
    if(N == 1) {puts("1.0");return 0;}
    for(int i = 1 ; i <= N ; ++i) {read(x);read(y);P[i] = Point(x,y);P[i].id = i;}
    for(int i = 2 ; i <= N ; ++i) {
    if(P[i].x < P[1].x || (P[i].x == P[1].x && P[i].y < P[1].y)) swap(P[1],P[i]);
    }
    sort(P + 2,P + N + 1,cmp);
    sta[++top] = P[1];
    for(int i = 2 ; i <= N ; ++i) {
    while(top >= 2 && (P[i] - sta[top - 1]) * (sta[top] - sta[top - 1]) >= 0.0) --top;
    sta[++top] = P[i];
    }
    if(top == 2) {
    ans[sta[1].id] = 0.5;
    ans[sta[2].id] = 0.5;
    }
    else {
    Point a,b;
    sta[0] = sta[top];sta[top + 1] = sta[1];
    for(int i = 1 ; i <= top ; ++i) {
        a = sta[i + 1] - sta[i];
        b = sta[i - 1] - sta[i];
        ans[sta[i].id] = (PI - acos( dot(a,b) / (a.norm() * b.norm()) ) ) / (2 * PI); 
    }
    }
    for(int i = 1 ; i <= N ; ++i) {
    printf("%.10lf\n",ans[i]);
    }
    return 0;
}

C - Tiling

按理来说是可以四个四个小块一划，如果多出来一行或者一列或者都多，就先贪心用<>填满多的一个横行，贪心用^v填满多余的一个纵行
但是有一个边界情况，就是横行纵行都剩一个，并且填满了，这个时候剩下了5个格子，有一个<>和一个^v没填
用3*3举个例子
<>^
^*v
v<>
可以这么填
也就是我们必须填多余格子的时候尽量靠右下填四个小块的时候尽量靠右上，剩出一个
**
**
*
来

#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define enter putchar('\n')
#define space putchar(' ')
#define MAXN 100005
#define eps 1e-8
//#define ivorysi
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;char c = getchar();T f = 1;
    while(c < '0' || c > '9') {
    if(c == '-') f = -1;
    c = getchar();
    }
    while(c >= '0' && c <= '9') {
    res = res * 10 + c - '0';
    c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) {
    out(x / 10);
    }
    putchar('0' + x % 10);
}
int N,M,A,B,S,T;
char ans[1005][1005];
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    read(N);read(M);read(A);read(B);
    S = N;T = M;
    if(N * M < (A + B) * 2) {
    puts("NO");
    return 0;
    }
    for(int i = 1 ; i <= N ; ++i) {
    for(int j = 1 ; j <= M ; ++j) {
        ans[i][j] = '.';
    }
    }
    if(M & 1) {
    int t = 1;
    while(B) {
        if(t + 1 > N) break;
        ans[t][M] = '^';
        ans[t + 1][M] = 'v';
        t += 2;
        --B;
    }
    --M;    
    }
    if(N & 1) {
    int t = T;
    while(A) {
        if(t - 1 < 1) break;
        ans[N][t] = '>';
        ans[N][t - 1] = '<';
        t -= 2;
        --A;
    }
    --N;
    }
    int rem = N * M;
    for(int i = 1 ; i <= N ; i += 2) {
    for(int j = M - 1 ; j >= 1 ; j -= 2) {
        if(A >= 2) {
        A -= 2;
        rem -= 4;
        ans[i][j] = '<';
        ans[i][j + 1] = '>';
        ans[i + 1][j] = '<';
        ans[i + 1][j + 1] = '>';
        }
        else if(B >= 2) {
        B -= 2;
        rem -= 4;
        ans[i][j] = '^';
        ans[i + 1][j] = 'v';
        ans[i][j + 1] = '^';
        ans[i + 1][j + 1] = 'v';
        }
    }
    }
    if(!A || !B || rem >= 8) {
    for(int i = 1 ; i <= N ; i += 2) {
        for(int j = M - 1 ; j >= 1 ; j -= 2) {
        if(ans[i][j] != '.') continue;
        if(A) {
            --A;
            ans[i][j] = '<';
            ans[i][j + 1] = '>';
        }
        else if(B) {
            --B;
            ans[i][j] = '^';
            ans[i + 1][j] = 'v';
        }
        }
    }
    }
    else if(rem >= 4){
    if(A == 1 && B == 1 && (S & 1) && (T & 1)) {
        --A;--B;
        ans[N - 1][1] = '<';ans[N - 1][2] = '>';
        ans[N][1] = '^';ans[N + 1][1] = 'v';
    } 
    }
    if(A || B) {puts("NO");return 0;}
    puts("YES");
    for(int i = 1 ; i <= S ; ++i) {
    for(int j = 1 ; j <= T ; ++j) {
        putchar(ans[i][j]);
    }
    enter;
    }
    return 0;
}

D - Reversed LCS

这怎么一道普及组题。。。
\(dp[i][j][k]\)表示区间\([i,j]\)改了\(k\)个字符
\(dp[i + 1][j][k] -> dp[i][j][k]\)
\(dp[i][j - 1][k] -> dp[i][j][k]\)
如果\(s[i] == s[j]\)
\(dp[i - 1][j + 1][k] + 2 -> dp[i][j][k]\)
如果\(s[i] != s[j]\)
\(dp[i - 1][j + 1][k] + 2 -> dp[i][j][k + 1]\)
初始化\(dp[i][i][0] = 1\)

#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define enter putchar('\n')
#define space putchar(' ')
#define MAXN 100005
#define eps 1e-8
//#define ivorysi
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;char c = getchar();T f = 1;
    while(c < '0' || c > '9') {
    if(c == '-') f = -1;
    c = getchar();
    }
    while(c >= '0' && c <= '9') {
    res = res * 10 + c - '0';
    c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) {
    out(x / 10);
    }
    putchar('0' + x % 10);
}
char s[305];
int K,dp[305][305][305],N;
void update(int &x,int y) {
    x = max(x,y);
}
void Solve() {
    scanf("%s",s + 1);
    read(K);
    N = strlen(s + 1);
    for(int i = 1 ; i <= N ; ++i) 
    for(int j = 0 ; j <= K ; ++j)
        dp[i][i][j] = 1;
    for(int d = 2 ; d <= N ; ++d) {
    for(int i = 1 ; i <= N ; ++i) {
        int j = i + d - 1;
        if(j > N) break;
        for(int k = 0 ; k <= K ; ++k) {
        if(k) update(dp[i][j][k],dp[i][j][k - 1]);
        update(dp[i][j][k],dp[i + 1][j][k]);
        update(dp[i][j][k],dp[i][j - 1][k]);
        if(s[i] == s[j]) update(dp[i][j][k],dp[i + 1][j - 1][k] + 2);
        else if(k) update(dp[i][j][k],dp[i + 1][j - 1][k - 1] + 2);
        }
    }
    }
    out(dp[1][N][K]);enter;
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    Solve();
    return 0;
}

E - Ball Eat Chameleons

这道题的题意应该是这个序列建立出来吃的方式可以自己定的

我们分析一下，显然红球数必须不少于蓝球数
设红球数为\(r\)，蓝球数为\(b\)
我们每个宠物都要分配至少一个红球，然后我们给\(N - 1\)个宠物都分配红球后，剩余的都给第一个，给了\(r - (N - 1)\)个
如果\(r - (N - 1) > b\)，那么无论怎样红蓝的先后顺序，我都可以让所有宠物变红，那么方案数就是\(\binom{K}{r}\)

在\(r != b\)时
设\(t = r - (N - 1)\)
设红球为1，蓝球为-1，那么前缀和必须大于\(-t\)
可以这么考虑，在\(N - 1\)只宠物没有分配红球时，来一个红球就给他们吃一个，之后如果来了一个蓝球，如果吃了红球的宠物没有吃过蓝球，让它们消耗一个蓝球
假如不存在这样的情况，我们就把蓝球都喂给第一个，如果喂到了t个蓝球，那么我无法使第一只变红了，我喂给别人的话，别人也没法变红了，所以就转化成了这个问题
方案数类似卡特兰数的证明
是\(\binom{K}{r} - \binom{K}{r + t}\)

在\(r == b\)时
还是类似上述情况，我还是选择给剩下的\(N - 1\)只各喂一个红球，一个蓝球，给第一只喂\(t\)个红球和蓝球
那么我在给第一只喂满\(t\)个蓝球之前，我必须把第一只的\(t\)个红球喂满了，这就要求了这个颜色的序列的最后一个值必须是-1
我们再考虑前\(K - 1\)个位置，我必须满足前缀和大于\(-t\)，那么答案就是\(\binom{K - 1}{r} - \binom{K - 1}{r + t}\)

#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define enter putchar('\n')
#define space putchar(' ')
#define MAXN 500005
#define eps 1e-8
//#define ivorysi
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;char c = getchar();T f = 1;
    while(c < '0' || c > '9') {
    if(c == '-') f = -1;
    c = getchar();
    }
    while(c >= '0' && c <= '9') {
    res = res * 10 + c - '0';
    c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) {
    out(x / 10);
    }
    putchar('0' + x % 10);
}
const int MOD = 998244353;
int N,K,fac[MAXN * 2],invfac[MAXN * 2],inv[MAXN * 2];
int inc(int a,int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}
int mul(int a,int b) {
    return 1LL * a * b % MOD;
}
int C(int n,int m) {
    if(n < m) return 0;
    return mul(fac[n],mul(invfac[m],invfac[n - m]));
}
void update(int &x,int y) {
    x = inc(x,y);
}
void Solve() {
    read(N);read(K);
    inv[1] = 1;
    for(int i = 2 ; i <= 1000000 ; ++i) inv[i] = mul(inv[MOD % i],MOD - MOD / i);
    invfac[0] = fac[0] = 1;
    for(int i = 1 ; i <= 1000000 ; ++i) {
    fac[i] = mul(fac[i - 1],i);
    invfac[i] = mul(invfac[i - 1],inv[i]);
    }
    int ans = 0;
    for(int i = 0 ; i <= K ; ++i) {
    int r = i,b = K - i;
    if(r < b || r < N) continue;
    if(r - (N - 1) > b) {
        update(ans,C(K,r));
    }
    else if(r == b) {
        int t = r - (N - 1);
        update(ans,inc(C(K - 1,r),MOD - C(K - 1,r + t)));
    }
    else {
        int t = r - (N - 1);
        update(ans,inc(C(K,r),MOD - C(K,r + t)));
    }
    }
    out(ans);enter;
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    Solve();
    return 0;
}

F - Trinity

考虑\(dp[i][j]\)表示\(i\)行\(j\)列方格填的方案数，多了一个限制是每行必须填一个数，所以我们枚举\(i\)，累加进答案\(\binom{n}{i} dp[i][M]\)即可

我们每次考虑增加一列的方案数
\(dp[p][j]\)转移到\(dp[p + q][j + 1]\)的方案
如果\(q\)是\(0\)的话，那么我这一列就剩\(B\)和\(C\)填的方式，有\(\binom{p + 1}{2} + 1\)多出来的1个是什么也不选，我们相当于加了一行，然后在\(p + 1\)中选两个，然后删掉加的一行，这样就包含进了这一列选了一个点的情况了

如果\(q\)不为0
我们考虑\(B,C\)可能不是我们新加进去的，而是原来\(p\)行中的，我们给\(p + q\)行首尾再加上附加的两行，然后选择\(q + 2\)个染黑，作为新加入的行，方案数是\(\binom{p + q + 2}{q + 2}\)
然后把多出来的两行删掉即可，如果删掉的首尾两行都没染黑，那么这个染黑的序列，首尾两个黑格子都是原来\(p\)行中的，如果首和尾都染黑了，那么这个\(p + q\)的序列，最上和最下两个黑格子都是新加入的\(q\)行中的，如果首行黑了尾行没黑，那么\(p + q\)的序列，最上的格子是\(q\)行中的，最下的格子是\(p\)行中的，另一种情况同理

可以卷积优化，所以就变成\(O(nm \log n)\)的了

#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define enter putchar('\n')
#define space putchar(' ')
#define MAXN 8005
#define eps 1e-8
//#define ivorysi
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;char c = getchar();T f = 1;
    while(c < '0' || c > '9') {
    if(c == '-') f = -1;
    c = getchar();
    }
    while(c >= '0' && c <= '9') {
    res = res * 10 + c - '0';
    c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) {
    out(x / 10);
    }
    putchar('0' + x % 10);
}
const int MOD = 998244353,MAXL = 1 << 14;
int N,M,fac[MAXN * 2],invfac[MAXN * 2],inv[MAXN * 2];
int f[MAXL + 5],g[MAXL + 5],dp[2][MAXN],W[MAXL + 5];
int mul(int a,int b) {
    return 1LL * a * b % MOD;
}
int inc(int a,int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}
int C(int n,int m) {
    if(n < m) return 0;
    return mul(fac[n],mul(invfac[m],invfac[n - m]));
}
int fpow(int x,int c) {
    int res = 1,t = x;
    while(c) {
    if(c & 1) res = mul(res,t);
    t = mul(t,t);
    c >>= 1;
    }
    return res;
}
void update(int &x,int y) {
    x = inc(x,y);
}
void FFT(int *p,int L,int on) {
    for(int i = 1 , j = L >> 1 ; i < L - 1 ; ++i) {
    if(i < j) swap(p[i],p[j]);
    int k = L >> 1;
    while(j >= k) {
        j -= k;
        k >>= 1;
    }
    j += k;
    }
    for(int h = 2 ; h <= L ; h <<= 1) {
    int wn = W[(MAXL + on * (MAXL / h)) % MAXL];
    for(int k = 0 ; k < L ; k += h) {
        int w = 1;
        for(int j = k ; j < k + h / 2 ; ++j) {
        int u = p[j],t = mul(w,p[j + h / 2]);
        p[j] = inc(u,t);
        p[j + h / 2] = inc(u,MOD - t);
        w = mul(w,wn);
        }
    }
    }
    if(on == -1) {
    int InvL = fpow(L,MOD - 2);
    for(int i = 0 ; i < L ; ++i) p[i] = mul(p[i],InvL);
    }
}
void Solve() {
    read(N);read(M);
    fac[0] = 1;
    for(int i = 1 ; i <= N + 10 ; ++i) fac[i] = mul(fac[i - 1],i);
    invfac[N + 10] = fpow(fac[N + 10],MOD - 2);
    for(int i = N + 9 ; i >= 0 ; --i) invfac[i] = mul(invfac[i + 1],i + 1);
    W[0] = 1;W[1] = fpow(3,(MOD - 1) / MAXL);
    for(int i = 2 ; i < MAXL ; ++i) W[i] = mul(W[i - 1],W[1]);
    int cur = 0;
    for(int i = 0 ; i <= N ; ++i) dp[cur][i] = 1;
    for(int i = 1 ; i <= N ; ++i) g[i] = invfac[i + 2];
    int L = 1;
    while(L <= 2 * N) L <<= 1;
    FFT(g,L,1);
    for(int i = 2 ; i <= M ; ++i) {
    memset(dp[cur ^ 1],0,sizeof(dp[cur ^ 1]));
    for(int j = 0 ; j <= N ; ++j) {
        update(dp[cur ^ 1][j],mul(dp[cur][j],inc(C(j + 1,2),1)));
    }
    memset(f,0,sizeof(f));
    for(int j = 0 ; j <= N ; ++j) f[j] = mul(dp[cur][j],invfac[j]);
    FFT(f,L,1);
    for(int j = 0 ; j < L ; ++j) f[j] = mul(f[j],g[j]);
    FFT(f,L,-1);
    for(int j = 0 ; j <= N ; ++j) {
        update(dp[cur ^ 1][j],mul(f[j],fac[j + 2]));
    }
    cur ^= 1;
    }
    int ans = 0;
    for(int i = 0 ; i <= N ; ++i) {
    update(ans,mul(C(N,i),dp[cur][i]));
    }
    out(ans);enter;
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    Solve();
    return 0;
}

转载于:https://www.cnblogs.com/ivorysi/p/9960176.html

王爷的大房子
关注
Atcoder AGC005 B Minimum Sum-思维
岂曰无衣，与子同袍
10-03 358
看到这道题的第一反应是线段树 然而小蒟蒻只会粘板 洋洋洒洒的代码实在是望而生畏 在Atcoder上浪了一波 看到tourist巨佬的程序 昨天晚上脑子有点挂机 没怎么看懂 今天早上爬起来看 实在是妙啊 不愧是巨佬 首先有一个巧妙的转化思想 就是枚举区间找最小值的复杂度很高 但我们可以去找每一个元素的“贡献区间” 而且这种关系是一一对应的 即是没有两个元素 对应同一个区间 后面的找区间和统计答案...
Atcoder agc021F
mayaohua
03-05 387
从左往右考虑每一列。设F[i][j]F[i][j]F[i][j]表示考虑到第iii列，已经有jjj行填了数，仅考虑这jjj行相对顺序的方案数。 转移的时候考虑先插入一些新的行，再确定BiB_iBi​和CiC_iCi​。对于插入kkk行（k>0k>0k>0）的非平凡情况，可以发现贡献系数是(i+k+2k+2){i+k+2}\choose{k+2}(k+2i+k+2​)，一个组合解释...
AtCoder AGC038D Unique Path (图论)
suncongbo's blog
09-23 277
题目链接 https://atcoder.jp/contests/agc038/tasks/agc038_d 题解 orz zjr神仙做法 考虑把所有\(C_i=0\)的提示的两点连边，那么连完之后的每个连通块都是一棵树 那么同一连通块内就不能出现\(C_i=1\)的提示，然后不同连通块之间可以任意连边，但是要满足两个连通块之间只能连一条边，还要连通 设有\(c\)个连通块，那么就要在连...
Atcoder agc021E
mayaohua
12-10 286
易知一只变色龙最后是红色，当且仅当他吃的红球比蓝球多或红蓝数目相等且最后一个是蓝球（至少吃一个红球）。 考虑如何判定一个方案是否合法。显然一个合法的方案红球数目不小于蓝球，不妨设红球比蓝球多ppp个（p≥0p\geq 0p≥0），那么红球有K+p2\frac{K+p}{2}2K+p​个，蓝球有K−p2\frac{K-p}{2}2K−p​个，这里要求红球数目至少是NNN。 显然当p≥Np\geq N...
【AtCoder】AGC011
weixin_30413739的博客
05-02 149
AGC011 A - Airport Bus 大意：有N个人，每个人只能在\([T_i,T_i +K]\)这段区间乘车，每辆车安排C人，问最少安排几辆车 直接扫，遇到一个没有车的在\(T_i +K\)分配一辆 #include <iostream> #include <algorithm> #include <cstdio> #include <...
【AtCoder】AGC034
weixin_30598225的博客
06-06 257
AGC034 刷了那么久AtCoder我发现自己还是只会ABCE（手动再见 A - Kenken Race 大意是一个横列，每个点可以跳一步或者跳两步，每个格子是空地或者石头，要求每一步不能走到石头或者有人的格子上，求是否能把\(A\)移动到\(C\)，\(B\)移动到\(D\)，\(A < C,B < D,A < B\) 看\(A\)到\(C\)和\(B\)到\(D\...
Atcoder agc026D
mayaohua
11-23 567
O(nlog⁡V)\mathcal O(n\log V)O(nlogV)出n=100n=100n=100的出题人nb。 对于一个2⋅22\cdot 22⋅2的矩阵，其中黑白格子数目相同的等价条件是考虑四个相邻格子的异或和，那么相对的两组异或和分别相等，且不能四个异或和均为000。 考虑如果给定的网格是n⋅mn\cdot mn⋅m的矩阵，我们确定了第一行和第一列的差分异或和的话，之后的每行每列也必须...
【题目记录】AtCoder - agc031 B
气派飞鹰的博客
05-23 100
题目链接 AtCoder - agc031 B 题意: 有一个长度为N的颜色序列，第i个位置初始颜色为ai, 可以执行若干次操作，每次可以选择两个颜色一样的位置，然后把这两个位置中间的区间都刷成和两端相同的颜色，问最后本质不同的序列有多少种。 题解: 最重要的想法就是要深刻地理解本质不同。 因为我们不论如何操作，最后得到的序列一样就算一样，假设[l1,r1]和[l2,r2]分别是先后两次操作。 若前者和后者相交但不包含，若前后两次刷成的颜色相同，我们可以等效成一次操作，操作区间为它们的并。若前后两次颜色不同
Atcoder agc035F
mayaohua
12-06 236
完全不会的神仙结论题。 考虑对于一个方案(k1,k2,...,kN,l1,l2,...,lM)(k_1,k_2,...,k_N,l_1,l_2,...,l_M)(k1​,k2​,...,kN​,l1​,l2​,...,lM​)，如果∃1≤i≤N\exist 1\leq i\leq N∃1≤i≤N使得lki+1=il_{k_i}+1=ilki​​+1=i，那么将kik_iki​减去111，lkil_...
Atcoder AGC050
Defener的博客
02-18 273
A 考虑到10≈log⁡2100010 \approx \log_2 100010≈log2​1000，每个页面向外连出两条边，要求任意两点距离不超过101010，因此建一颗类似于线段树的图。点 ppp 连向模意义下的点 2p2p2p 和 2p+12p+12p+1 即可。 时间复杂度 O(n)O(n)O(n)，空间复杂度 O(1)O(1)O(1) #include<iostream> using namespace std; int main(){ int n,a,b; cin>&gt
Atcoder agc028F
mayaohua
12-06 484
考虑从大往小枚举左上角(i,j)(i,j)(i,j)，求出所有能到达的点的权值和sum[i][j]sum[i][j]sum[i][j]。 如果(i,j+1)(i,j+1)(i,j+1)和(i+1,j)(i+1,j)(i+1,j)中至多只有一个非障碍格子，那么容易计算。否则直接加上sum[i][j+1]sum[i][j+1]sum[i][j+1]和sum[i+1][j]sum[i+1][j]sum[...
Atcoder agc031E
mayaohua
03-05 364
考虑费用流。拆点行列模型，枚举总共选的个数kkk，理解成从小到大选匹配的kkk个横坐标和kkk个纵坐标。额外增加kkk个对应选择横坐标的点和kkk个对应选择纵坐标的点，我们可以将mmm个限制转化为对这2k2k2k个点选择范围的限制，这样可以得到一个点数为O(N+k)\mathcal O(N+k)O(N+k)，边数为O(Nk)\mathcal O(Nk)O(Nk)的图，对它跑费用流即可。 因为流量是...
Atcoder agc024E
mayaohua
03-05 274
倒着考虑，从一个给定的ANA_NAN​不断删除字符能得到多少种不同的方案。为了不计重复，我们要求每次删掉一个字符xix_ixi​时，满足xi+1≠xix_{i+1}\neq x_ixi+1​​=xi​，那么合法的条件是∃j≥i,xi=xi+1=...=xj,xj+1<xi\exist j\geq i,x_i=x_{i+1}=...=x_j,x_{j+1}<x_i∃j≥i,xi​=xi...
Atcoder agc023E
mayaohua
11-02 413
这个题感觉比较简单？可是场上只过了777个人。 如果要计数有多少个排列是经典问题，按AiA_iAi​排序后，答案就是∏i=1n(Ai−i+1)\prod_{i=1}^{n}(A_i-i+1)∏i=1n​(Ai​−i+1)。 现在要求逆序对的总数，显然考虑枚举点对计数。假设我们算的是(i,j)(i<j)(i,j)(i<j)(i,j)(i<j)的贡献，那么当Ai≤AjA_i \leq...
【做题记录】AtCoder AGC做题记录
suncongbo's blog
06-26 221
做一下AtCoder的AGC锻炼一下思维吧 目前已做题数: 127 总共题数: 269 每一场比赛后面的字母是做完的题，括号里是写完题解的题 AGC001: ABCDEF (DEF) AGC002: ABCEF (EF) AGC003: ABE AGC004: EF (EF) AGC005: EF (E) AGC006: CD AGC007: E (E) AGC009: E (E) AG...
Atcoder agc020E
mayaohua
11-26 337
这题看上去就有一股乱搞的感觉。 注意到答案显然可以DP，对于一个字符串SSS，我们令F[S]F[S]F[S]代表SSS的所有子集的编码方案数之和。那么考虑最左边被编码的是哪个子串，有F[S]=(1+[S1=1])⋅F[S2...∣s∣]+∑ij≤nF[S1...i and Si+1...2i and ...S(j−1)i+1...ij]⋅F[Sij+1......
【Atcoder】AGC020 C-F简要题解
远行客
03-22 369
E.区间DP F.神仙DP
Atcoder agc027D
mayaohua
11-13 186
我们令m=1m=1m=1，对网格黑白染色后，要求白格的权值比相邻的黑格大，并且模相邻的黑格余111。 不考虑ai,j≤1015a_{i,j}\leq 10^{15}ai,j​≤1015的限制的话，有一个显然的构造，令黑格取不同的奇质数，白格取相邻黑格的lcm+1lcm+1lcm+1，这样显然互不相同且合法，问题是权值太大了。 考虑调整一下这个做法，我们给每条主对角线和反对角线分别对应一个奇质数，每...
atcoder agc002 D[克魯斯卡爾重構樹+倍增]
zjc0201的博客
12-06 483
D - Stamp Rally Time limit : 2sec / Memory limit : 256MB Problem Statement We have an undirected graph with N vertices and M edges. The vertices are numbered 1 through N, and the edges are numbered 1...
Atcoder AGC002 F ： Leftmost Ball（DP）
DZYO的博客
03-15 372
传送门 题解： 很妙的一道题。 考虑怎么统计得不重不漏，每一种方案的除了白点的每一种颜色第一个出现的位置一定不同而且有顺序， 我们可以强制这个顺序为1→n1→n1 \rightarrow n, 最后乘上n!n!n!。 同时，我们可以把每种方案的白点按照这个顺序赋颜色 （因为每一种方案这样赋颜色肯定合法，而且每一种合法的方案这样染色回去一定对应一种原始方案，所以他们的关系是双射）。 现在问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值