ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

2022.8.22 颓废记录

2022-08-23 00:30:45  阅读：166  来源： 互联网

标签：std sz le 颓废 22 int maxn 2022.8 ans


Preface

没有序言

Content

[luogu P4059][Code+#1]找爸爸

题面太长难以概括，不写简要题目了QAQ。

首先发现，肯定没有两个对应位置都是空格的，否则可以去掉让答案更优。

因此，我们只需要考虑最后一位是不是空格，如果是，讨论它在小 A 还是小 B。

具体而言，令 \(dp(i,j,k)\) 表示两个字符串分别匹配 \(i,j\) 个字符的最大相似度，且：

  • \(k=0\)：最后一位都不是空格，有 \(dp(i,j,k=0)=\max\{dp(i-1,j-1,0/1/2)\}\)。

  • \(k=1\)：小 A 的最后一位是空格，则有 \(dp(i,j,k=1)=\max\{dp(i,j-1,0)-A,dp(i,j-1,1)-B,dp(i,j-1,2)-A\}\)。

  • \(k=2\)：小 B 最后一位为空格，则有 \(dp(i,j,k=2)=\max\{dp(i-1,j,0)-A,dp(i-1,j,1)-A,dp(i-1,j,2)-B\}\)。

时间复杂度 \(O(nm)\)。

Code

// Problem: P4059 [Code+#1]找爸爸
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P4059
// Memory Limit: 500 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
const int maxn = 3005;
typedef long long ll;
int pos[200];
ll dp[maxn][maxn][3],d[5][5],A,B;
char s[maxn],t[maxn];
int main() {
    pos['A'] = 1;
    pos['T'] = 2;
    pos['G'] = 3;
    pos['C'] = 4;
    scanf("%s%s",s + 1,t + 1);
    int n = strlen(s + 1),m = strlen(t + 1);
    for(int i = 1;i <= 4;++ i) {
        for(int j = 1;j <= 4;++ j) {
            scanf("%lld",&d[i][j]);
        }
    }
    scanf("%lld %lld",&A,&B);
    for(int i = 1;i <= max(n , m);++ i) {
        dp[0][i][0] = dp[i][0][0] = dp[0][i][2] = dp[i][0][1] = -1ll << 60;
        dp[0][i][1] = dp[i][0][2] = -A - 1ll * B * (i - 1);
    }
    for(int i = 1;i <= n;++ i) {
        for(int j = 1;j <= m;++ j) {
            dp[i][j][0] = max(dp[i - 1][j - 1][0] , max(dp[i - 1][j - 1][1] , dp[i - 1][j - 1][2])) + d[pos[s[i]]][pos[t[j]]];
            dp[i][j][1] = max(dp[i][j - 1][0] - A , max(dp[i][j - 1][1] - B , dp[i][j - 1][2] - A));
            dp[i][j][2] = max(dp[i - 1][j][0] - A , max(dp[i - 1][j][1] - A , dp[i - 1][j][2] - B));
        }
    }
    printf("%lld",max(dp[n][m][0] , max(dp[n][m][1] , dp[n][m][2])));
    return 0;
}

[CF1030E]Vasya and Good Sequences

你可以进行一种操作，每次操作可以交换一个数某两个二进制位上的数值。

如果你可以通过若干次操作使得 \(b\) 序列所有数异或和为 \(0\)，那么称 \(b\) 序列是好序列。

给定 \(a_{1\sim n}\)，求有多少 \([l,r]\) 满足 \(a_{l\sim r}\) 是一个好序列。

\(1\le n\le 3\times 10^5,1\le a_i\le 10^{18}\)。

首先我们需要知道 \(a_{l\sim r}\) 是好序列的条件。

显然第一个条件是 \(a_{l\sim r}\) 中的数的二进制 \(1\) 的个数必须为偶数。

并且，\(1\) 的个数最多的那个数 \(1\) 的个数不能超过总体的个数的一半。

可以发现，只要满足这两个条件，总能构造出一个异或和为 \(0\) 的序列。

第一点很好统计，直接前缀和加上统计数组维护。

至于第二点，显然这样的 \([l,r]\) 满足 \(r-l+1\) 不超过 \(64\)，直接暴力统计即可。

时间复杂度 \(O(64n)\)。

Code

// Problem: CF1030E Vasya and Good Sequences
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1030E
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
typedef long long ll;
int n;
ll sum,cnt[2],ans,a[maxn];
int popcount(ll x) {
    int ans = 0;
    for(;x;x -= x & -x)++ ans;
    return ans;
}
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie();
    std::cout.tie();
    std::cin >> n;
    for(int i = 1;i <= n;++ i)std::cin >> a[i],a[i] = popcount(a[i]);
    sum = 0;
    ++ cnt[0];
    for(int i = 1;i <= n;++ i) {
        ans += cnt[(sum += a[i]) & 1] ++;
        ll res = 0,maxval = 0;
        for(int j = i;j <= std::min(n , i + 58);++ j) {
            res += a[j];
            maxval = std::max(maxval , a[j]);
            ans -= (!(res & 1)) and (maxval > res / 2);
        }
    }
    std::cout << ans << endl;
    return 0;
}

[CF852B]Neural Network country

有一幅有向图，除了源点和汇点有 \(L\) 层，每层 \(n\) 个点。 第 \(i+1\) 层的每个点到第 \(i+2\) 层的每个点都有一条边，边的权值为有向边终点的权值。求源点到汇点的路径长度能被 \(m\) 整除的个数。

\(1\le n\le 10^6,1\le L\le 10^5,1\le m\le 100\)。

\(n,L\) 范围很离谱而 \(m\) 很小，一眼矩阵快速幂优化 DP。

直接预处理矩阵跑矩乘是 \(O(nm+m^3\log L)\) 的，可以通过但不完美。

其实这里没必要用矩乘，直接用几个行向量做一个类似卷积的东西就行。

（这么说起来这玩意是不是还可以用多项式优化 QAQ）

要注意的是源点和第 \(1\) 层，第 \(L\) 层和汇点要特殊处理。

时间复杂度 \(O(n+m^2\log L)\)。

Code

// Problem: CF852B Neural Network country
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF852B
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
const int maxm = 105;
int n,k,m;
struct matrix {
    int g[maxm];
    matrix() {
        memset(g , 0 , sizeof(g));
    }
}f,A,B;
matrix operator * (const matrix& a,const matrix& b) {
    matrix c;
    for(int i = 0;i < m;++ i) {
        for(int j = 0;j < m;++ j) {
            (c.g[(i + j) % m] += 1ll * a.g[i] * b.g[j] % mod) %= mod;
        }
    }
    return c;
}
int a[maxn];
matrix power(matrix x,int y) {
    matrix ans;
    ans.g[0] = 1;
    for(;y;y >>= 1) {
        if(y & 1)ans = ans * x;
        x = x * x;
    }
    return ans;
}
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    std::cin >> n >> k >> m;
    for(int i = 1;i <= n;++ i) {
        std::cin >> a[i];
        ++ f.g[a[i] % m];
    }
    for(int i = 1;i <= n;++ i) {
        std::cin >> a[i];
        ++ A.g[a[i] % m];
    }
    for(int i = 1;i <= n;++ i) {
        int x;
        std::cin >> x;
        ++
 B.g[(x + a[i]) % m];
    }
    f = f * power(A , k - 2) * B;//才发现这里写成 printf 了，这是怎么过的QAQ
    //printf("%d\n",f.g[0]);
    std::cout << f.g[0];
    return 0;
}

[CF771C]Bear and Tree Jumps

给定一棵 \(n\) 个结点的树和一个整数 \(k\)。

每次可以从一个节点 \(u\) 跳到树上距离 \(u\) 不超过 \(k\) 的某个节点。

定义 \(f(u,v)\) 表示从 \(u\) 跳到 \(v\) 的最小步数。

求 \(\sum\limits_{1\le s\lt t\le n}f(s,t)\)。

\(1\le n\le 2\times 10^5,1\le k\le 5\)

这个题面是不是在预示着我要 fst 了

简单的换根 DP，只不过一开始一直没有往这个方向想，一直在硬算。

设 \(f(u,i)\) 表示从 \(u\) 跳到 \(u\) 子树中与 \(u\) 的距离 \(\bmod k\) 为 \(i\) 的节点的最小步数之和，\(sz(u,i)\) 表示 \(u\) 的子树中与 \(u\) 距离 \(\bmod k\) 为 \(i\) 的节点个数。

好绕啊QAQ

显然有：

\[sz(u,(i+1)\bmod k)=\sum_{v\in son_u} sz(v,i) \\ f(u,1\bmod k)=\sum_{v\in son_u}f(v,0)+sz(v,0) \\ f(u,(i+1)\bmod k)=\sum_{v\in son_u}f(v,i)(i\neq 0) \]

换根的时候撤销 \(v\) 的贡献，把 \(u\) 贡献到 \(v\) 里，然后最后回溯一下就行。

时间复杂度 \(O(nk)\)。

当然，如果这题树边有权值，就需要淀粉质来帮忙了，具体珂以看 zzyz 神仙云浅的题解。

本来想写一下，但是太懒，咕了（逃

Code

// Problem: CF771C Bear and Tree Jumps
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF771C
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
#define pb emplace_back
using namespace std;
const int maxn = 2e5 + 5;
int n,k;
vector<int> G[maxn];
typedef long long ll;
ll f[maxn][5],sz[maxn][5],ans;
void dfs1(int u,int fa) {
    sz[u][0] = 1;
    for(auto& v : G[u]) {
        if(v == fa)continue ;
        dfs1(v , u);
        for(int i = 0;i < k;++ i) {
            sz[u][(i + 1) % k] += sz[v][i];
            f[u][(i + 1) % k] += f[v][i];
            if(!i)f[u][1 % k] += sz[v][i];
        }
    }
    return ;
}
void dfs2(int u,int fa) {
    for(int i = 0;i < k;++ i)ans += f[u][i];
    for(auto& v : G[u]) {
        if(v == fa)continue ;
        ll Fu[5],Fv[5],Sizeu[5],Sizev[5];
        for(int i = 0;i < k;++ i) {
            Fu[i] = f[u][i];
            Fv[i] = f[v][i];
            Sizeu[i] = sz[u][i];
            Sizev[i] = sz[v][i];
        }
        for(int i = 0;i < k;++ i) {
            sz[u][(i + 1) % k] -= sz[v][i];
            f[u][(i + 1) % k] -= f[v][i];
            if(!i)f[u][1 % k] -= sz[v][i];
        }
        for(int i = 0;i < k;++ i) {
            sz[v][(i + 1) % k] += sz[u][i];
            f[v][(i + 1) % k] += f[u][i];
            if(!i)f[v][1 % k] += sz[u][i];
        }
        dfs2(v , u);
        for(int i = 0;i < k;++ i) {
            f[u][i] = Fu[i];
            f[v][i] = Fv[i];
            sz[u][i] = Sizeu[i];
            sz[v][i] = Sizev[i];
        }
    }
    return ;
}
int main() {
    scanf("%d %d",&n,&k);
    for(int i = 1;i < n;++ i) {
        int u,v;
        scanf("%d %d",&u,&v);
        G[u].pb(v);
        G[v].pb(u);
    }
    dfs1(1 , 0);
    dfs2(1 , 0);
    printf("%lld\n",ans >> 1ll);
    return 0;
}

[luogu P5906]【模板】回滚莫队&不删除莫队

没什么好说的，模板题，直接放代码。

Code

// Problem: P5906 【模板】回滚莫队&不删除莫队
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P5906
// Memory Limit: 128 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
#define pb emplace_back
using namespace std;
const int maxn = 2e5 + 5;
int FIR[maxn];
int n,m,a[maxn],c[maxn],bel[maxn],fir[maxn],lst[maxn],ans[maxn],L[maxn],R[maxn];
struct query {
	int l,r,id;
	query() {
		l = r = id = 0;
	}
}Q[maxn];
int main() {
	scanf("%d",&n);
	for(int i = 1;i <= n;++ i)scanf("%d",&a[i]),c[i] = a[i];
	sort(c + 1 , c + 1 + n);
	int tot = unique(c + 1 , c + 1 + n) - c - 1;
	for(int i = 1;i <= n;++ i)a[i] = lower_bound(c + 1 , c + 1 + tot , a[i]) - c;
	int t = sqrt(n);
	for(int i = 1;i <= t;++ i) {
		L[i] = R[i - 1] + 1;
		R[i] = i * t;
	}
	if(t * t < n) {
		L[t + 1] = R[t] + 1;
		R[t + 1] = n;
		++ t;
	}
	for(int i = 1;i <= t;++ i) {
		for(int j = L[i];j <= R[i];++ j) {
			bel[j] = i;
		}
	}
	scanf("%d",&m);
	for(int i = 1;i <= m;++ i) {
		scanf("%d %d",&Q[i].l,&Q[i].r);
		Q[i].id = i;
	}
	sort(Q + 1 , Q + 1 + m , [&](const query& p,const query& q) {
		return (bel[p.l] ^ bel[q.l]) ? bel[p.l] < bel[q.l] : p.r < q.r;
	});
	int del[maxn],cnt;
	for(int k = 1,i = 1;k <= t;++ k) {
		int l = R[k] + 1,r = R[k],now = 0;
		cnt = 0;
		for(;bel[Q[i].l] == k;++ i) {
			if(bel[Q[i].l] == bel[Q[i].r]) {
				int res = 0;
				for(int j = Q[i].l;j <= Q[i].r;++ j) {
					if(!FIR[a[j]])FIR[a[j]] = j;
					res = max(res , j - FIR[a[j]]);
				}
				ans[Q[i].id] = res;
				for(int j = Q[i].l;j <= Q[i].r;++ j) {
					FIR[a[j]] = 0;
				}
				continue ;
			}
			for(;r < Q[i].r;) {
				++ r;
				if(!fir[a[r]])fir[a[r]] = r,del[++ cnt] = a[r];
				lst[a[r]] = r;
				now = max(now , r - fir[a[r]]);
			}
			int tmp = now;
			for(;l > Q[i].l;) {
				-- l;
				if(!lst[a[l]])lst[a[l]] = l;
				now = max(now , lst[a[l]] - l);
			}
			ans[Q[i].id] = now;
			for(;l <= R[k];++ l) {
				if(lst[a[l]] == l)lst[a[l]] = 0;
			}
			now = tmp;
		}
		for(int j = 1;j <= cnt;++ j)fir[del[j]] = lst[del[j]] = 0;
	}
	for(int i = 1;i <= m;++ i)printf("%d\n",ans[i]);
	return 0;
}

[CF700B]Connecting Universities

\(n\) 个结点的树，有 \(2k\) 个特殊节点，把它们分成 \(k\) 对，使得每对节点间的距离之和最大。

\(2\le n\le 2\times 10^5,1\le k\le \frac{n}{2}\)。

考虑贪心。

看到求距离，使用经典的处理手法，考虑每条边的贡献。

显然，每条边的最大贡献值就是左端特殊节点个数和右端特殊节点个数的最小值。

多写几组数据发现，一定可以构造一种方案使得每条边的贡献值最大化。

所以跑一遍 DFS 就完事了。时间复杂度 \(O(n)\)。

Code

// Problem: CF700B Connecting Universities
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF700B
// Memory Limit: 250 MB
// Time Limit: 3000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
#define pb emplace_back
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 5;
int n,k,sz[maxn];
vector<int> G[maxn];
ll ans;
void dfs(int u,int fa) {
	for(auto& v : G[u]) {
		if(v == fa)continue ;
		dfs(v , u);
		sz[u] += sz[v];
		ans += min(sz[v] , 2 * k - sz[v]);
	}
	return ;
}
int main() {
	scanf("%d %d",&n,&k);
	for(int i = 1;i <= 2 * k;++ i) {
		int x;
		scanf("%d",&x);
		++ sz[x];
	}
	for(int i = 1;i < n;++ i) {
		int u,v;
		scanf("%d %d",&u,&v);
		G[u].pb(v);
		G[v].pb(u);
	}
	dfs(1 , 0);
	printf("%lld\n",ans);
	return 0;
}

好困QAQ，睡了，不写了。

标签：std,sz,le,颓废,22,int,maxn,2022.8,ans
来源： https://www.cnblogs.com/Royaka/p/16614738.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有