Codeforces Round #263 (Div. 1)

最新推荐文章于 2024-08-08 01:44:08 发布
最新推荐文章于 2024-08-08 01:44:08 发布
阅读量534 收藏
点赞数
分类专栏： 数据结构 字符串 组合计数 矩阵 套题整理 codeforces 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011277193/article/details/40819665
版权 
Codeforces 461 A. Appleman and Toastman:简单的贪心.

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <string>
#include <vector>
#include <cstdio>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define cntbit __builtin_popcount
using namespace std;
//#pragma comment(linker,"/STACK:102400000,102400000")

typedef long long LL;

const int maxn = 300000 + 333;

LL a[maxn];
LL sum[maxn];

int MAIN()
{
    int n;
    cin>>n;
    for (int i = 1; i <= n; i ++) {
        cin>>a[i];
    }
    if (n == 1) {
        cout<<a[1]<<endl;
        return 0;
    }
    sort(a, a + n + 1);
    sum[n] = a[n];
    LL ans = 0;
    for (int i = n - 1; i >= 1; i --) {
        sum[i] = sum[i + 1] + a[i];
        ans += sum[i];
    }
    ans += sum[1];
    cout<<ans<<endl;
    return 0;
}

int main()
{
	ios :: sync_with_stdio(false);
	return MAIN();
}

Codeforces 461 B. Appleman and Tree
题意:给定一棵包含n个节点的树,这棵树的一些节点(至少一个)被染成黑色,现在可以删除一些边,使得删完边后的每个联通分量中恰好只有一个黑色节点.问满足条件的方案数一共有多少(对1e9+7取mod).
解法:树形dp.
dp[u][0]:以u为根的子树没有一个黑色节点的方法数;
dp[u][1]:以u为根的子树恰好只有一个黑色节点的方法数.
如果点u的颜色是黑色:则dp[u][1]为所有孩子(dp[v][0]+dp[v][1])的积.(因为对于一个孩子节点v,如果以v为根的子树此时是不包含黑色节点的,那么此时必定与u连边,如果是包含一个黑色节点的,则必定与u不连边.也就是说,对于每一个儿子节点的每个状态,都有了一个决策去连或者不连边.)
如果点u的颜色是白色:则dp[u][0]为所有孩子(dp[v][0]+dp[v][1])的积(原因类似).
而对于dp[u][1]的计算有两种计算方法.
方法一:由于dp[u][0]已经计算,那么对于一个孩子v,u选择与v为根的包含一个黑色节点的连边的方法数就是dp[u][0]/(dp[v][0]+dp[v][1])*dp[v][1].这一步需要求乘法逆元,最终程序的复杂度为nlogn.
方法二:可以类似dp的思想同时计算dp[u][0]与dp[u][1],初始状态下dp[u][0]=1,dp[u][1]=0.对于每一个孩子v,dp的转移方程如下:dp[u][0]=dp[u][0]*(dp[v][0]+dp[v][1]),dp[u][1]=dp[u][0]*dp[v][1]+dp[u][1]*(dp[v][0]+dp[v][1]).这样的复杂度是O(n).
这样的两种dp方法实际上也是在树形dp中经常出现的两种方法.

/*
 注意点:
 1.树形dp的时候,如果是写成dfs(u,fa)的形式,不需要vis数组
 2.分清楚子树和根之间的关系,注意好到底是乘法原理还是加法原理
 比如说这道题,子树的状态只是决定了根和子树之间的边的状态,所以对于每棵子树的每一个状态,我都可以选择是否删除对应的边来达到某个状态
 */
#include <cstdio>
#include <cstring>
#include <set>
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <iostream>
#include <iomanip>
#include <list>
#include <queue>
#define REP(i, n) for ((i) = 0; (i) < (int)(n); ++ (i))

using namespace std;

typedef long long LL;

const int maxn = 100000 + 100;
const LL  MOD  = 1000000000 + 7;

LL dp[maxn][2];
int c[maxn];
vector<int> g[maxn];

void dfs(int u, int fa)
{
    if (c[u] == 1) {
        dp[u][1] = 1;
        for (int i = 0; i < g[u].size(); i ++) {
            int v = g[u][i];
            if (v != fa) {
                dfs(v, u);
                dp[u][1] = (dp[u][1] * ((dp[v][0] + dp[v][1]) % MOD)) % MOD;
            }
        }
    }
    else
    {
        dp[u][0] = 1;
        for (int i = 0; i < g[u].size(); i ++) {
            int v = g[u][i];
            if (v != fa) {
                dfs(v, u);
                LL v1, v2;
                v1 = dp[u][0] * ((dp[v][0] + dp[v][1]) % MOD) % MOD;
                v2 = (dp[u][0] * dp[v][1] % MOD) + dp[u][1] * ((dp[v][0] + dp[v][1]) % MOD) % MOD;
                v2 = v2 % MOD;
                dp[u][0] = v1;
                dp[u][1] = v2;
            }
        }
    }
}


/*
void extend_gcd(LL a,LL b,LL &d,LL &x,LL &y)
{
    if(!b)
    {
        d=a;
        x=1;
        y=0;
    }else{
        extend_gcd(b,a%b,d,y,x);
        y-=x*(a/b);
    }
}

LL inv(LL a,LL n)
{
    LL d,x,y;
    extend_gcd(a, n, d, x, y);
    return d == 1? (x+n)%n:-1;
}

void dfs(int u, int fa)
{
    int size = (int)g[u].size();
    int i;
    REP(i, size)
    {
        int v = g[u][i];
        if (v == fa)    continue;
        dfs(v, u);
    }
    if (c[u] == 1) {
        dp[u][1] = 1;
        REP(i, size)
        {
            int v = g[u][i];
            if (v == fa)    continue;
            dp[u][1] = dp[u][1] * ((dp[v][0] + dp[v][1]) % MOD) % MOD;
        }
    }
    else
    {
        dp[u][0] = 1;
        REP(i, size)
        {
            int v = g[u][i];
            if (v == fa)    continue;
            dp[u][0] = dp[u][0] * ((dp[v][0] + dp[v][1]) % MOD) % MOD;
        }
        REP(i, size)
        {
            int v = g[u][i];
            if (v == fa)    continue;
            LL val = dp[u][0] * inv(dp[v][0] + dp[v][1], MOD) % MOD;
            dp[u][1] +=  val * dp[v][1] % MOD;
        }
        dp[u][1] %= MOD;
    }
}
*/

int MAIN()
{
    int n;
    cin>>n;
    int p;
    for (int i = 0; i + 1 < n; i ++) {
        cin>>p;
        g[p].push_back(i + 1);
        g[i + 1].push_back(p);
    }
    for (int i = 0; i < n; i ++) {
        cin>>c[i];
    }
    dfs(0, -1);
    LL ans = dp[0][1];
    ans = (ans + MOD) % MOD;
    cout<<ans<<endl;
    return 0;
}

int main()
{
    ios :: sync_with_stdio(false);
    cout << fixed << setprecision(16);
    return MAIN();
}


Codeforces 461 C. Appleman and a Sheet of Paper
题意:给定一张长度为n的纸,每次会选择一个点作为中心对折.动态询问当前折纸从l到r这一段的总厚度(初始状态下厚度为1).
解法:树状数组,implementation,也需要正确地估计时间复杂度.
对于任意一个状态下的折纸,我们用l,r和方向sgn来描述(比如从左向右折纸的但是右边那块长度很短的话可以看作是从右向左折纸),而对于每一步的折纸操作,直接把原来地方的厚度加到了现在的位置.利用树状数组可以在求和和加上的复杂度为logn.而总的折纸并做加的操作并不会大于n.所以总的复杂度是O(n*logn+q*logn).
/*
 树状数组的应用
 对复杂度的正确估计
 */

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
using namespace std;

const int MaxN = 100000;

int n;
int bit[MaxN + 1];

inline void bit_add(int p, int x)
{
    for (int i = p; i <= n; i += i & -i)
        bit[i] += x;
}
inline int bit_query(int p)
{
    int res = 0;
    for (int i = p; i >= 1; i -= i & -i)
        res += bit[i];
    return res;
}

int main()
{
    int nQ;
    static int a[MaxN + 1];
    
    cin >> n >> nQ;
    for (int i = 1; i <= n; i++)
        a[i] = 1, bit_add(i, 1);
    
    int le = 1, ri = n, d = 1;
    while (nQ--)
    {
        int type;
        scanf("%d", &type);
        if (type == 1)
        {
            int len;
            scanf("%d", &len);
            
            if (len * 2 <= abs(le - ri) + 1)
            {
                for (int i = 0; i < len; i++)
                {
                    bit_add(le + (len + i) * d, a[le + (len - i - 1) * d]);
                    a[le + (len + i) * d] += a[le + (len - i - 1) * d];
                }
                le += len * d;
            }
            else
            {
                len = abs(le - ri) + 1 - len;
                for (int i = 0; i < len; i++)
                {
                    bit_add(ri - (len + i) * d, a[ri - (len - i - 1) * d]);
                    a[ri - (len + i) * d] += a[ri - (len - i - 1) * d];
                }
                ri -= len * d;
                
                d *= -1;
                swap(le, ri);
            }
        }
        else if (type == 2)
        {
            int l, r;
            scanf("%d %d", &l, &r);
            r--;
            
            l = le + l * d;
            r = le + r * d;
            if (l > r)
                swap(l, r);
            
            int res = bit_query(r) - bit_query(l - 1);
            printf("%d\n", res);
        }
    }
    
    return 0;
}


Codeforces 461 D. Appleman and Complicated Task
题意:给定一个n*n的表,每个格子可以填上o或者x,需要每个格子周围的o的个数都是偶数.给定k个格子已经填的数,问满足题目要求的放置方法一共有多少种.
解法:假设o为1,x为0.我们发现,第一行的状态就决定了所有格子的状态.再利用异或关系,题目等价为a[i]^a[i+1]^...^a[j]=k,给定若干组(i,j,k),问长度为n的可能有多少种.
这个问题可以利用并查集解决,每个a[i]拆为两个点2*i,2*i+1.
若k为1,则将2*i与2*(j+1)+1合并,2*i+1与2*(j+1)合并.
若k为0,则将2*i与2*(j+1)合并,2*i+1与2*(j+1)+1合并.
最后答案为2^(集合数/2),若2*i与2*i+1在一个集合,答案为0.
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <string>
#include <vector>
#include <cstdio>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define cntbit __builtin_popcount
using namespace std;
//#pragma comment(linker,"/STACK:102400000,102400000")

typedef long long LL;

const int maxn = 100000 + 100;
const int mod = 1000000000 + 7;

int fa[maxn<<1];
int cnt;

int find(int x)
{
    if (fa[x] == x) {
        return x;
    }
    else
    {
        return fa[x] = find(fa[x]);
    }
}

void merge(int a, int b)
{
    a = find(a);
    b = find(b);
    if (a != b) {
        cnt --;
        fa[b] = a;
    }
}

int abs(int x)
{
    return x < 0 ? -x : x;
}

int MAIN()
{
	int n, k;
    cin>>n>>k;
    cnt = 2 * n + 4;
    for (int i = 0; i < cnt; i ++) {
        fa[i] = i;
    }
    int a, b;
    char op[2];
    while (k --) {
        cin>>a>>b>>op;
        a--, b--;
        int l, r;
        l = abs(a - b);
        r = min(a + b, 2 * n - 2 - a - b);
        if (op[0] == 'o') {
            merge(2 * l, 2 * (r + 2) + 1);
            merge(2 * l + 1, 2 * (r + 2));
        }
        else
        {
            merge(2 * l, 2 * (r + 2));
            merge(2 * l + 1, 2 * (r + 2) + 1);
        }
    }
    for (int i = 0; i < n + 2; i ++) {
        if (find(2 * i) == find(2 * i + 1)) {
            cout<<"0"<<endl;
            return 0;
        }
    }
    cnt = (cnt - 4) / 2;
    int ans = 1;
    for (int i = 0; i < cnt; i ++) {
        ans = (ans + ans) % mod;
    }
    cout<<ans<<endl;
    return 0;
}

int main()
{
	ios :: sync_with_stdio(false);
	return MAIN();
}


Codeforces 461 E. Appleman and a Game
题意:给定两个串,s,t.如果从空串开始,每次只能在已有的串之后添加t的子串,可以得到最少的操作次数.现在给定s的长度,你需要确定构造出一个满足条件的s后,最多需要操作的次数.串t保证只出现A,B,C,D四个字母,并且每个字母至少出现1次.
解法:字符串,dp,矩阵.
假设给定了一个字符串s,我们的策略肯定是每次写尽可能长的子串,相反,要想s写的次数尽可能多,我们希望每次填写的子串尽可能短.
dp[k][c1][c2]:由k个字符串拼接而成,头字符是c1,末尾之后字符是c2的字符串的最短长度.
dp[k+1][c1][c2]=min(dp[k+1][c1][c2],dp[k][c1][c3]+dp[1][c3][c2]),这一步dp过程可以利用矩阵来加速.
接下来需要计算dp[1][c1][c2].我们枚举长度为L的字符串,如果该字符串不在t中出现过,则更新答案dp[1][c1][c2]=min(dp[1][c1][c2],L-1).注意到t的长度不超过10^5,所以我们枚举的长度应该不超过log4(T)+1.
之后二分答案,注意二分的写法.
#include <cstdio>
#include <cstring>
#include <set>
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <iostream>
#include <iomanip>
#include <list>
#include <queue>
#define REP(i, n) for ((i) = 0; (i) < (int)(n); ++ (i))

using namespace std;

typedef long long ll;
const ll INF = 1ll << 60;
const int MAXN = 100000 + 100;
int g[4][4], n;
bool f[1ll << 20];
char t[MAXN];
int r[MAXN];
ll four[10];

void check(int l)
{
    int i, j;
    REP(i, four[l])    f[i] = false;
    for (i = 0; i + l - 1 < n; ++ i) {
        int tmp = 0;
        REP(j, l)
        {
            tmp = tmp * 4 + r[i + j];
        }
        f[tmp] = true;
    }
    REP(i, four[l])
    {
        if (!f[i]) {
            int s = i / four[l - 1];
            int e = i % 4;
            g[s][e] = min(g[s][e], l - 1);
        }
    }
}


struct Matrix
{
    ll a[4][4];
};

Matrix pro(Matrix A, Matrix B)
{
    int i, j, k;
    Matrix C;
    REP(i, 4)   REP(j, 4)   C.a[i][j] = INF;
    REP(i, 4)
    {
        REP(j, 4)
        {
            REP(k, 4)
            {
                C.a[i][k] = min(C.a[i][k], A.a[i][j] + B.a[j][k]);
            }
        }
    }
    return C;
}

ll cal(ll k)
{
    Matrix A, B;
    int i, j;
    REP(i, 4)   REP(j, 4)   A.a[i][j] = g[i][j];
    REP(i, 4)   REP(j, 4)   B.a[i][j] = 0;
    for (i = 0; i < 60; ++ i)
    {
        if ((k >> i) & 1) {
            B = pro(B, A);
        }
        A = pro(A, A);
    }
    ll ans = INF;
    REP(i, 4)   REP(j, 4)   ans = min(ans, B.a[i][j]);
    return ans;
}

int MAIN()
{
    ll x;
    scanf("%lld", &x);
    scanf("%s", t);
    n = (int)strlen(t);
    int i, j;
    REP(i, n)   r[i] = t[i] - 'A';
    four[0] = 1;
    for (i = 1; i < 10; ++ i)   four[i] = 4 * four[i - 1];
    REP(i, 4)   REP(j, 4)   g[i][j] = 10;
    for (i = 2; i <= 10; ++ i)  check(i);
    //REP(i, 4)   REP(j, 4)   cout << i << " "  << j << " " << g[i][j] << endl;
    ll left = 0, right = INF;
    ll ans = 1;
    while (left <= right) {
        ll mid = (left + right) >> 1;
        ll val = cal(mid);
        if (val < x) {
            ans = mid;
            left = mid + 1;
        }
        else
        {
            right = mid - 1;
        }
    }
    printf("%lld\n", ans + 1);
    return 0;
}

int main()
{
    cout << fixed << setprecision(16);
    //ios :: sync_with_stdio(false);
    return MAIN();
}


pizzaaaaa
关注
专栏目录
Codeforces Round #724 (Div. 2)题解A-D
Arctic_Clam的博客
06-07 408
A. Omkar and Bad Story 分析： 显然有负数存在不可能满足题意，故输出NO。 如果只有非负数的话，那么直接输出以0开头，100结尾的，公差为1的等差数列即可。因为值域是[-100,100]，而数组大小的限制是三百以内。 代码： #include <iostream> #include <algorithm> using namespace std; int a[110]; int main() { int t; cin >> t; wh
Codeforces Round #739 (Div. 3) ABCDEF1F2 解题思路
StelaYuri's Blog
08-19 560
Codeforces Round #739 (Div. 3) 可能是一开始大佬都写F1去了，我在D写完后发现F过的人数比E多了好多（个位数与十位数），以为F1比较简单，就直接开F1了，但自己分类讨论老是考虑不完整，导致罚时直接垮掉 本来已经不想开E了，结果发现延长了15分钟，尝试着开一开，结果发现很水……现在在怀疑人生了嗯。 UPD: F2已补 A - Dislike of Threes 思路 数据范围小（k≤1000k\le 1000k≤1000），暴力预处理后输出即可。 代码 // URL: htt
Codeforces Round 964 (Div. 4)
最新发布
2301_76888784的博客
08-08 834
感觉F题应该是可以做出来的，但是赛时没有想到阶乘预处理导致计算组合数超时，算是重大失误，还有C提交了三发才找到问题所在。
Codeforces Round #263 (Div. 1) A B C
weixin_34415923的博客
06-08 130
Codeforces Round #263 (Div. 1) A:贪心。排个序，然后从后往前扫一遍，计算后缀和。之后在从左往右扫一遍计算答案 B：树形DP。0表示没有1，1表示有1，0遇到0必定合并。0遇到1也必定合并，1遇到0必定合并。1遇到1，必定切断，依照这样去转移就可以 C：树状数组，再利用启示式合并，开一个l，r记录当前被子左右下标。和一个flip表示是否翻...
Codeforces Round #263 Div.1 B Appleman and Tree --树形DP【转】
whatbeg
11-27 509
题意：给了一棵树以及每个节点的颜色，1代表黑，0代表白，求将这棵树拆成k棵树，使得每棵树恰好有一个黑色节点的方法数 解法：树形DP问题。定义： dp[u][0]表示以u为根的子树对父亲的贡献为0 dp[u][1]表示以u为根的子树对父亲的贡献为1 现在假设u为白色，它的子树有x，y，z，那么有 dp[u][1]+=dp[x][1]*dp[y][0]*dp[z][0]+dp[x][0]*d
Codeforces Round #263 (Div.1) B. Appleman and Tree
Charlie Pan's Blog
08-27 1477
题目地址：http://codeforces.com/contest/461/problem/B 题目大意：给一棵树，每个点为白色或黑色，切断一些边，使得每个连通块有且仅有一个黑点，问划分方案数。 算法讨论：TreeDP。f[x][0..1]表示x所在连通块有0/1个黑点。设y为x的儿子，则DP方程为f[x][1]=f[x][1]*f[y][0]+f[x][1]*f[y][1]+f[x][0]
Codeforces Round #263 (Div. 1) C. Appleman and a Sheet of Paper
Charlie Pan's Blog
08-27 1522
题目地址：http://codeforces.com/contest/461/problem/C 题目大意：见原题。 算法分析：启发式暴力，每次把短的纸带折到长的纸带中，在全局记一个rev标记。注意细节。 Code: #include #include #define N 100000 using namespace std; bool rev; int n,q,beg=1,en
Codeforces Round 857 div.2
m0_53089164的博客
03-10 989
小明有两个朋友，进了n家商店，每家商店有价格为a[i]，b[i] 的两个商品，小明要么给1号朋友买a[i]，要么给2号朋友买b[i]，怎么买能使给1号朋友和给2号朋友买的最贵的礼物差值最小 每家商店都要买礼物，每个朋友至少有一个礼物 输出：两个最贵的礼物的差值
Codeforces Round #161 (Div. 2) B. Squares
weixin_33923762的博客
06-26 345
题目：http://codeforces.com/contest/263/problem/B 在第一象限画n个以原点为顶点，(ai,ai)为对角顶点的正方形 输出任意一个k为顶点的正方形 思路：任意一个点，选正方形的顶点 #include <iostream> #include <cstdlib> using namespace std; int ar...
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include #include #include #include #include #include #...
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
传送门 题意： 一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到...
Codeforces Round #479 (Div. 3) E. Cyclic Components
01-03
E. Cyclic Components 题目链接-E. Cyclic Components 题目大意 给你nnn个点和mmm条边，求所构成图中单圈环的个数 ...并查集并查集并查集 很明显单圈环每个点的度都为222，所以我们可以用数组cnt[]记录每个点的度，...
477 C. Dreamoon and Strings
\*zyeric*/
11-02 852
题意:给定字符串s,t.问s串删除k个字符后,最多有多少个互不相交的子序列和p相等. 解法:dp[i][j]:字符s[i]之前删除了j个字符后的答案. 对于s[i]的每一位设置一个转移位点to[i],表示以s[i]开始的串匹配t的最后一个位置加上1. dp转移方程: dp[i+1][j]=max(dp[i+1][j],dp[i][j])//这一步主要是为了那些不在to[]中的位点更新值.
449 D. Jzzhu and Numbers
\*zyeric*/
07-25 733
/* 容斥原理... 题意:给定n个数(n<=10^6),ai<=10^6.问有多少种选取方式使得ai1^ai2^...^aik=0. i1<i2<...<ik 考虑对x,有多少个ai使得ai&x=x,令此等于f(x),再令g(x) = x二进制表示中1的个数 则最后的答案为sigma(0<=x<(1<<20))(-1)^g(x)*2^(f(x)). 是容斥原理逐步淘汰的形式(也就是求
477 D. Dreamoon and Binary
\*zyeric*/
11-02 690
好久不写CSDN了，
448 E. Divisors
\*zyeric*/
08-04 677
#include #include #include using namespace std; const int maxn = 1e5; #define LL long long vector divi; vector ans; void solve(LL x,LL k) { if(x==1) { ans.push_back(1);
424 B. Megacity
\*zyeric*/
07-26 629
/* 按距离排序后直接模拟 */ #include #include #include #include using namespace std; #define LL long long struct point { LL x,y; int k; }; bool cmp(const point &p,const point &q) { return p.x*
Codeforces Round 712 (Div. 1)
08-29
- *1* *2* *3* [Codeforces Round #712 (Div. 1) A. Balance the Bits](https://blog.csdn.net/qq_45554473/article/details/127872159)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值