Zengtudor
/
ProgramAlgTrain
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

change to utf8

This commit is contained in:
Zengtudor 2024-09-19 11:11:59 +08:00
parent 3c0dc6f9a5
commit a926d878d1
20 changed files with 104 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
20240919/CSP常考算法模板/BFS.cpp
View File

@ -7,30 +7,30 @@ struct node {
queue<node> q; queue<node> q;
int a[51][51]; int a[51][51];
int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; // 方向数组 int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; // 方向数组
bool flag = false, book[51][51]; bool flag = false, book[51][51];
int n, m, sx, sy, ex, ey; int n, m, sx, sy, ex, ey;
void bfs(int sx,int sy) void bfs(int sx,int sy)
{ {
q.push({sx, sy, 0}); // 星星之火, 可以燎原 q.push({sx, sy, 0}); // 星星之火, 可以燎原
book[sx][sy] = true; book[sx][sy] = true;
while(!q.empty() && !flag) { while(!q.empty() && !flag) {
node temp = q.front(); node temp = q.front();
q.pop(); q.pop();
for(int i=0; i<4;i++) { for(int i=0; i<4;i++) {
//算出新的位置坐标 //算出新的位置坐标
int nx = temp.x + dir[i][0]; int nx = temp.x + dir[i][0];
int ny = temp.y + dir[i][1]; int ny = temp.y + dir[i][1];
//判断新的位置是否越界 //判断新的位置是否越界
if(nx<1 || nx > n || ny < 1 || ny > m) if(nx<1 || nx > n || ny < 1 || ny > m)
continue; continue;
// 如果新的位置是平地 并且 没有走过 // 如果新的位置是平地 并且 没有走过
if(a[nx][ny]==0 && !book[nx][ny]) { if(a[nx][ny]==0 && !book[nx][ny]) {
q.push({nx, ny, temp.s+1}); q.push({nx, ny, temp.s+1});
book[nx][ny] = true; book[nx][ny] = true;
// 新的位置是否为终点 // 新的位置是否为终点
if(nx==ex && ny==ey) { if(nx==ex && ny==ey) {
flag = true; flag = true;
cout<<temp.s+1; cout<<temp.s+1;
@ -68,6 +68,6 @@ int main() {
0 0 0 1 0 0 0 1
1 1 4 3 1 1 4 3
输出 输出
7 7
*/ */

26
20240919/CSP常考算法模板/DFS.cpp
View File

@ -4,37 +4,37 @@ using namespace std;
int n,m,p,q,minn=INT_MAX; int n,m,p,q,minn=INT_MAX;
int a[51][51]; int a[51][51];
bool book[51][51]; bool book[51][51];
// 方向数组 // 方向数组
int dir[4][2]={ {0,1} , //向右走 int dir[4][2]={ {0,1} , //向右走
{1,0} , //向下走 {1,0} , //向下走
{0,-1}, //向左走 {0,-1}, //向左走
{-1,0} } ;//向上走 {-1,0} } ;//向上走
void dfs(int x,int y,int step){ void dfs(int x,int y,int step){
// 判断是否到终点 // 判断是否到终点
if(x==p && y==q){ if(x==p && y==q){
minn = min(minn, step); minn = min(minn, step);
return; return;
} }
// 剪枝 // 剪枝
if(step>=minn) // 如果未到终点步数就已经达到或超过最小值，就返回。 if(step>=minn) // 如果未到终点步数就已经达到或超过最小值，就返回。
return; return;
// 枚举每一个方向 // 枚举每一个方向
for(int i=0; i<=3; i++){ for(int i=0; i<=3; i++){
//计算下一个点的坐标 //计算下一个点的坐标
int nx=x+dir[i][0]; int nx=x+dir[i][0];
int ny=y+dir[i][1]; int ny=y+dir[i][1];
// 判断是否越界 // 判断是否越界
if(nx<1 || nx>n || ny<1 || ny>m) if(nx<1 || nx>n || ny<1 || ny>m)
continue; continue;
if(a[nx][ny]==0 && !book[nx][ny]){ if(a[nx][ny]==0 && !book[nx][ny]){
book[nx][ny]=true; book[nx][ny]=true;
dfs(nx,ny,step+1); dfs(nx,ny,step+1);
book[nx][ny]=false; // 回溯 book[nx][ny]=false; // 回溯
} }
} }
@ -46,7 +46,7 @@ int main(){
int i ,j,startx,starty; int i ,j,startx,starty;
cin>>n>>m; cin>>n>>m;
//读入迷宫 //读入迷宫
for(i=1;i<=n;i++) for(i=1;i<=n;i++)
for(j=1;j<=m;j++) for(j=1;j<=m;j++)
cin>>a[i][j]; cin>>a[i][j];

18
20240919/CSP常考算法模板/LCA_倍增.cpp
View File

@ -10,7 +10,7 @@ struct Edge {
int n,m,s; int n,m,s;
int depth[N], Log[N]; int depth[N], Log[N];
int dbl[N][20]; //倍增数组 int dbl[N][20]; //倍增数组
int head[N], tot; int head[N], tot;
void addEdge(int x,int y) { void addEdge(int x,int y) {
@ -24,18 +24,18 @@ void dfs(int cur, int fa) {
dbl[cur][0]=fa; dbl[cur][0]=fa;
for(int i=1; (1<<i) < depth[cur]; i++) { for(int i=1; (1<<i) < depth[cur]; i++) {
int mid = dbl[cur][i-1]; int mid = dbl[cur][i-1];
dbl[cur][i]=dbl[mid][i-1]; // 计算倍增数组 dbl[cur][i]=dbl[mid][i-1]; // 计算倍增数组
} }
for(int i=head[cur]; i>0; i=e[i].nxt) { for(int i=head[cur]; i>0; i=e[i].nxt) {
if(e[i].to != fa) // 遍历子节点 if(e[i].to != fa) // 遍历子节点
dfs(e[i].to, cur); dfs(e[i].to, cur);
} }
} }
int lca(int x,int y) { int lca(int x,int y) {
// 把两个点升至同一高度，再一起跳 // 把两个点升至同一高度，再一起跳
if(depth[x]<depth[y]) { // 规定x更深 if(depth[x]<depth[y]) { // 规定x更深
swap(x,y); swap(x,y);
} }
@ -46,7 +46,7 @@ int lca(int x,int y) {
if(x==y) if(x==y)
return x; return x;
// 两个点同时往上跳，跳到LCA的下一层为止 // 两个点同时往上跳，跳到LCA的下一层为止
for(int i=Log[depth[x]]; i>=0; i--) for(int i=Log[depth[x]]; i>=0; i--)
if(dbl[x][i] != dbl[y][i]) { if(dbl[x][i] != dbl[y][i]) {
x=dbl[x][i]; x=dbl[x][i];
@ -57,7 +57,7 @@ int lca(int x,int y) {
} }
/* /*
倍增算法时间复杂度是O(nlogn) 倍增算法时间复杂度是O(nlogn)
*/ */
int main() { int main() {
scanf("%d%d%d",&n,&m,&s); scanf("%d%d%d",&n,&m,&s);
@ -67,9 +67,9 @@ int main() {
addEdge(x,y); addEdge(x,y);
addEdge(y,x); addEdge(y,x);
} }
dfs(s,0); // 建树 dfs(s,0); // 建树
// 预处理，常数优化 // 预处理，常数优化
for(int i=2; i<=n; i++) { for(int i=2; i<=n; i++) {
Log[i]=Log[i>>1] + 1; Log[i]=Log[i>>1] + 1;
} }

12
20240919/CSP常考算法模板/P3379【模板】LCA_倍增 -邻接表.cpp
View File

@ -5,7 +5,7 @@ const int N = 500001;
int n,m,s; int n,m,s;
int depth[N], Log[N]; int depth[N], Log[N];
int dbl[N][20]; //倍增数组 int dbl[N][20]; //倍增数组
int tot; int tot;
vector<int> graph[N]; vector<int> graph[N];
@ -28,7 +28,7 @@ void dfs(int cur, int fa) {
} }
int lca(int x,int y) { int lca(int x,int y) {
// 把两个点升至同一高度，再一起跳 // 把两个点升至同一高度，再一起跳
// TODO // TODO
if(depth[x]<depth[y]) if(depth[x]<depth[y])
{ {
@ -43,7 +43,7 @@ int lca(int x,int y) {
if(x==y) if(x==y)
return x; return x;
// 两个点同时往上跳，跳到LCA的下一层为止 // 两个点同时往上跳，跳到LCA的下一层为止
// TODO // TODO
int h=Log[depth[x]]; int h=Log[depth[x]];
for(int i=h;i>=0;i--) for(int i=h;i>=0;i--)
@ -58,7 +58,7 @@ int lca(int x,int y) {
} }
/* /*
倍增算法时间复杂度是O(nlogn) 倍增算法时间复杂度是O(nlogn)
*/ */
int main() { int main() {
scanf("%d%d%d",&n,&m,&s); scanf("%d%d%d",&n,&m,&s);
@ -69,9 +69,9 @@ int main() {
graph[x].push_back(y); graph[x].push_back(y);
graph[y].push_back(x); graph[y].push_back(x);
} }
dfs(s,0); // 建树 dfs(s,0); // 建树
// 预处理，常数优化 // 预处理，常数优化
for(int i=2; i<=n; i++) { for(int i=2; i<=n; i++) {
//todo //todo
Log[i]=Log[i/2]+1; Log[i]=Log[i/2]+1;

12
20240919/CSP常考算法模板/P3379【模板】LCA_倍增 -邻接表_todo.cpp
View File

@ -5,7 +5,7 @@ const int N = 500001;
int n,m,s; int n,m,s;
int depth[N], Log[N]; int depth[N], Log[N];
int dbl[N][20]; //倍增数组 int dbl[N][20]; //倍增数组
int tot; int tot;
vector<int> graph[N]; vector<int> graph[N];
@ -14,20 +14,20 @@ void dfs(int cur, int fa) {
} }
int lca(int x,int y) { int lca(int x,int y) {
// 把两个点升至同一高度，再一起跳 // 把两个点升至同一高度，再一起跳
// TODO // TODO
if(x==y) if(x==y)
return x; return x;
// 两个点同时往上跳，跳到LCA的下一层为止 // 两个点同时往上跳，跳到LCA的下一层为止
// TODO // TODO
return dbl[x][0]; return dbl[x][0];
} }
/* /*
倍增算法时间复杂度是O(nlogn) 倍增算法时间复杂度是O(nlogn)
*/ */
int main() { int main() {
scanf("%d%d%d",&n,&m,&s); scanf("%d%d%d",&n,&m,&s);
@ -36,9 +36,9 @@ int main() {
scanf("%d%d",&x,&y); scanf("%d%d",&x,&y);
//todo //todo
} }
dfs(s,0); // 建树 dfs(s,0); // 建树
// 预处理，常数优化 // 预处理，常数优化
for(int i=2; i<=n; i++) { for(int i=2; i<=n; i++) {
//todo //todo
} }

8
20240919/CSP常考算法模板/RMQ.cpp
View File

@ -4,7 +4,7 @@ using namespace std;
const int N = 1e6 + 5; const int N = 1e6 + 5;
const int LOGN = 20; const int LOGN = 20;
int Log[N] = {-1}, f[N][LOGN + 1], a[N]; // f[i][j] 存储[i, i+2^j-1]之间的最值 int Log[N] = {-1}, f[N][LOGN + 1], a[N]; // f[i][j] 存储[i, i+2^j-1]之间的最值
int n, m; int n, m;
int main() { int main() {
@ -18,11 +18,11 @@ int main() {
for(int i=1; i<=n; ++i) { for(int i=1; i<=n; ++i) {
f[i][0]=a[i]; f[i][0]=a[i];
Log[i]=Log[i>>1] + 1; // 预处理出长度为1~n的log值 Log[i]=Log[i>>1] + 1; // 预处理出长度为1~n的log值
} }
for(int j=1; j<=LOGN; j++) { // 注意是j for(int j=1; j<=LOGN; j++) { // 注意是j
for(int i=1; i+(1<<j)-1<=n; i++) { // 注意要加括号(1<<j) for(int i=1; i+(1<<j)-1<=n; i++) { // 注意要加括号(1<<j)
f[i][j]=max(f[i][j-1], f[i+(1<<(j-1))][j-1]); f[i][j]=max(f[i][j-1], f[i+(1<<(j-1))][j-1]);
} }
} }

2
20240919/CSP常考算法模板/全排列.cpp
View File

@ -1,6 +1,6 @@
#include<bits/stdc++.h> #include<bits/stdc++.h>
using namespace std; using namespace std;
bool book[10]; //false表示没用过 bool book[10]; //false表示没用过
int a[10]; int a[10];
void print() void print()

16
20240919/CSP常考算法模板/区间dp/区间dp_合并石子.cpp
View File

@ -5,14 +5,14 @@ int a[101];
int sum[101]; // prefix sum int sum[101]; // prefix sum
int f[101][101]; int f[101][101];
/* /*
区间动态规划解题步骤： 区间动态规划解题步骤：
1.根据问题推测dp[i][j]的含义 1.根据问题推测dp[i][j]的含义
问题是：把第1堆到第n堆石子合成一堆，最小的得分 问题是：把第1堆到第n堆石子合成一堆，最小的得分
dp[i][j]的含义：把第i堆到第j堆石子合成一堆，最小的得分 dp[i][j]的含义：把第i堆到第j堆石子合成一堆，最小的得分
2.根据规则推出dp[i][j]的状态转移公式 2.根据规则推出dp[i][j]的状态转移公式
在i-j之间选一个中间值k， 在i-j之间选一个中间值k，
dp[i][j]=dp[i][k]+dp[k+1][j]+(sum[j]-s[i-1]); dp[i][j]=dp[i][k]+dp[k+1][j]+(sum[j]-s[i-1]);
3.边界问题（比如设定dp[0][0],dp[0][j],dp[i][0],dp[i][j],dp[i][i]初始值） 3.边界问题（比如设定dp[0][0],dp[0][j],dp[i][0],dp[i][j],dp[i][i]初始值）
*/ */
@ -41,7 +41,7 @@ int main() {
sum[i] = sum[i-1] + a[i]; sum[i] = sum[i-1] + a[i];
} }
for(int i=n-1; i>=1; i--) { //一定要逆序 for(int i=n-1; i>=1; i--) { //一定要逆序
for(int j=i+1; j<=n; j++) { for(int j=i+1; j<=n; j++) {
f[i][j] = INT_MAX; f[i][j] = INT_MAX;
for(int k=i; k<=j-1; k++) { for(int k=i; k<=j-1; k++) {

6
20240919/CSP常考算法模板/快速幂.cpp
View File

@ -4,8 +4,8 @@ using namespace std;
int b, p, k; int b, p, k;
/* /*
原理：a*b%k=(a%k)*(b%k)%k 原理：a*b%k=(a%k)*(b%k)%k
对于任何一个自然数：p=2*(p/2)+p%2 对于任何一个自然数：p=2*(p/2)+p%2
*/ */
int f(int p) { int f(int p) {
if(p==0) // b^0%k if(p==0) // b^0%k
@ -13,7 +13,7 @@ int f(int p) {
int t=f(p/2)%k; int t=f(p/2)%k;
t=(t*t)%k; // b^p%k=(b^(p/2))^2%k t=(t*t)%k; // b^p%k=(b^(p/2))^2%k
if(p%2==1) if(p%2==1)
t=(t*b)%k; // 如果p为奇数，则b^p%k=((b^(p/2))^2)*b%k t=(t*b)%k; // 如果p为奇数，则b^p%k=((b^(p/2))^2)*b%k
return t; return t;
} }

2
20240919/CSP常考算法模板/最小生成树/最小生成树_Prim(稠密图)..cpp
View File

@ -9,7 +9,7 @@ int dis[101];
int ans, cnt; int ans, cnt;
vector<edge> graph[101]; vector<edge> graph[101];
bool visit[101]; bool visit[101];
struct cmp //仿函数 struct cmp //
{ {
bool operator()(const edge &a, const edge &b) { bool operator()(const edge &a, const edge &b) {
return a.w > b.w; return a.w > b.w;

6
20240919/CSP常考算法模板/最小生成树/最小生成树_kruskal(稀疏图).cpp
View File

@ -13,7 +13,7 @@ bool cmp(edge x, edge y) {
} }
//int getDistance(int x1, int y1, int x2, int y2) { //int getDistance(int x1, int y1, int x2, int y2) {
// return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2); // 最后要求距离的平方 // return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2); // 最后要求距离的平方
//} //}
int n, m; int n, m;
@ -27,7 +27,7 @@ void merge(int x, int y) {
int fx = find(x); int fx = find(x);
int fy = find(y); int fy = find(y);
if (fx != fy) { if (fx != fy) {
//如果不在一个集合 //如果不在一个集合
f[fy] = fx; f[fy] = fx;
} }
} }
@ -59,7 +59,7 @@ int main() {
for (int j = 1; j <= m; j++) { for (int j = 1; j <= m; j++) {
cin>>a[j].x>>a[j].y>>a[j].w; cin>>a[j].x>>a[j].y>>a[j].w;
} }
sort(a + 1, a + m + 1, cmp); //排序 sort(a + 1, a + m + 1, cmp); //排序
kruskal(); kruskal();
cout << ans << endl; cout << ans << endl;
return 0; return 0;

8
20240919/CSP常考算法模板/最短路径/单源最短路径Dijkstra.cpp
View File

@ -15,10 +15,10 @@ int rs, re, ci;
int dis[N]; int dis[N];
bool vis[N]; bool vis[N];
struct cmp //仿函数 struct cmp //仿函数
{ {
bool operator()(point a, point b) { bool operator()(point a, point b) {
return a.len > b.len; //priority_queue的排序规则与sort的规则相反 return a.len > b.len; //priority_queue的排序规则与sort的规则相反
} }
}; };
@ -27,11 +27,11 @@ priority_queue<point, vector<point>, cmp> pq;
void Dijkstra() void Dijkstra()
{ {
memset(dis, 0x3f, sizeof(dis)); memset(dis, 0x3f, sizeof(dis));
dis[ts] = 0; // 注意起 始点是ts！！！ dis[ts] = 0; // 注意起 始点是ts！！！
pq.push({ts, 0}); pq.push({ts, 0});
while (pq.size()>0) { while (pq.size()>0) {
int id = pq.top().id; // 取出当前距离源点最近的点 int id = pq.top().id; // 取出当前距离源点最近的点
pq.pop(); pq.pop();
if (vis[id]) continue; if (vis[id]) continue;

4
20240919/CSP常考算法模板/最短路径/单源最短路径SPFA(有负边）.cpp
View File

@ -1,7 +1,7 @@
#include <bits/stdc++.h> #include <bits/stdc++.h>
using namespace std; using namespace std;
int dis[2501]; int dis[2501];
bool exist[2501];//标记每个点是否在queue中 bool exist[2501];//标记每个点是否在queue中
struct point struct point
{ {
int to; int to;
@ -13,7 +13,7 @@ vector<point> graph[2501];
void SPFA() void SPFA()
{ {
memset(dis, 0x3f, sizeof(dis)); memset(dis, 0x3f, sizeof(dis));
dis[s] = 0; // 注意起 始点是s！！！ dis[s] = 0; // 注意起 始点是s！！！
queue<int> q; queue<int> q;
q.push(s); q.push(s);
exist[s]=1; exist[s]=1;

8
20240919/CSP常考算法模板/最短路径/多源最短路径Floyed.cpp
View File

@ -12,20 +12,20 @@ int main()
for (i = 1; i <= n; i++) for (i = 1; i <= n; i++)
cin >> a[i][1] >> a[i][2]; cin >> a[i][1] >> a[i][2];
cin >> m; cin >> m;
memset(f,0x7f,sizeof(f)); //初始化f数组为最大值 memset(f,0x7f,sizeof(f)); //初始化f数组为最大值
//预处理出x、y间距离 //预处理出x、y间距离
// for (i = 1; i <= m; i++) // for (i = 1; i <= m; i++)
// { // {
// cin >> x >> y; // cin >> x >> y;
// f[y][x] = f[x][y] = sqrt(pow(a[x][1]-a[y][1],2)+pow(a[x][2]-a[y][2],2)); // f[y][x] = f[x][y] = sqrt(pow(a[x][1]-a[y][1],2)+pow(a[x][2]-a[y][2],2));
// //pow(x,y)表示x^y，其中x,y必须为double类型，要用cmath库 // //pow(x,y)表示x^y，其中x,y必须为double类型，要用cmath库
// } // }
for (i = 1; i <= n; i++) for (i = 1; i <= n; i++)
f[i][i]=0; f[i][i]=0;
cin >> s >> e; cin >> s >> e;
for (k = 1; k <= n; k++) //k表示中转点 //floyed 最短路算法 for (k = 1; k <= n; k++) //k表示中转点 //floyed 最短路算法
{ {
for (i = 1; i <= n; i++) for (i = 1; i <= n; i++)
{ {

12
20240919/CSP常考算法模板/树上问题_dfs.cpp
View File

@ -3,16 +3,16 @@ using namespace std;
const int MAXN = 1e5 + 5; const int MAXN = 1e5 + 5;
//dep[u]代表u的深度 //dep[u]代表u的深度
//leaf[u]代表以u为根的子树中，深度最浅的那个叶子节点的深度。 //leaf[u]代表以u为根的子树中，深度最浅的那个叶子节点的深度。
int n , m , rt , leaf[MAXN] , dep[MAXN]; int n , m , rt , leaf[MAXN] , dep[MAXN];
vector<int> graph[MAXN]; vector<int> graph[MAXN];
// 算出dep[u]和leaf[u] // 算出dep[u]和leaf[u]
int dfs(int u, int fa) { // 返回距离u点最近的叶子节点深度 int dfs(int u, int fa) { // 返回距离u点最近的叶子节点深度
dep[u] = dep[fa] + 1; dep[u] = dep[fa] + 1;
// u是叶子节点 // u是叶子节点
if(graph[u].size()==1) { if(graph[u].size()==1) {
leaf[u] = dep[u]; leaf[u] = dep[u];
return leaf[u]; return leaf[u];
@ -25,7 +25,7 @@ int dfs(int u, int fa) { //
return leaf[u]; return leaf[u];
} }
// 节点u能够被控制所需的farmer数量 // 节点u能够被控制所需的farmer数量
int dfs2(int u, int fa) { int dfs2(int u, int fa) {
if(dep[u] - 1 >= leaf[u] - dep[u]) return 1; if(dep[u] - 1 >= leaf[u] - dep[u]) return 1;
int cnt = 0; int cnt = 0;

10
20240919/CSP常考算法模板/线性dp_求最长不下降序列_逆推.cpp
View File

@ -7,7 +7,7 @@ int a[100], dp[100], trace[100];
14 14
13 7 9 16 38 24 37 18 44 19 21 22 63 15 13 7 9 16 38 24 37 18 44 19 21 22 63 15
输出 输出
max=8 max=8
7 9 16 18 19 21 22 63 7 9 16 18 19 21 22 63
*/ */
@ -17,12 +17,12 @@ int main()
cin>>n; cin>>n;
for(int i=1; i<=n; i++) for(int i=1; i<=n; i++)
{ {
cin>>a[i]; // 原始数据 cin>>a[i]; // 原始数据
dp[i]=1; // LIS dp[i]=1; // LIS
trace[i]=0; // 上一个数的位置 trace[i]=0; // 上一个数的位置
} }
// 求LIS // 求LIS
for(int i=n-1; i>=1; i--) for(int i=n-1; i>=1; i--)
{ {
int maxlis=0; int maxlis=0;
@ -51,7 +51,7 @@ int main()
} }
cout<<"max="<<dp[pos]<<endl; cout<<"max="<<dp[pos]<<endl;
// 输出最长不下降序列 // 输出最长不下降序列
while(pos!=0) while(pos!=0)
{ {
cout<<a[pos]<<" "; cout<<a[pos]<<" ";

20
20240919/CSP常考算法模板/线段树(区间修改，区间查询).cpp
View File

@ -6,28 +6,28 @@ const int SIZE = 1e6;
struct node{ struct node{
int l, r; int l, r;
LL w; // 区间和 LL w; // 区间和
}; };
node tree[4*SIZE + 1]; // 开4倍大小 node tree[4*SIZE + 1]; // 开4倍大小
inline void build(int k, int l, int r) { // k代表当前节点编号 inline void build(int k, int l, int r) { // k代表当前节点编号
tree[k].l = l; tree[k].l = l;
tree[k].r = r; tree[k].r = r;
if (l == r) { // 叶子节点 if (l == r) { // 叶子节点
scanf("%lld", &tree[k].w); scanf("%lld", &tree[k].w);
return; return;
} }
int mid = l + r >> 1; // 相当于 (l + r) >> 1 k int mid = l + r >> 1; // 相当于 (l + r) >> 1 k
int lc = k << 1, rc = lc | 1; int lc = k << 1, rc = lc | 1;
build(lc, l, mid); // 左子树 build(lc, l, mid); // 左子树
build(rc, mid + 1, r); // 右子树 build(rc, mid + 1, r); // 右子树
tree[k].w = tree[lc].w + tree[rc].w; tree[k].w = tree[lc].w + tree[rc].w;
} }
// 单点修改 // 单点修改
inline void changePoint(int k, int x, int c) { inline void changePoint(int k, int x, int c) {
if (tree[k].l == tree[k].r) { // 找到叶子节点 if (tree[k].l == tree[k].r) { // 找到叶子节点
tree[k].w += c; tree[k].w += c;
return; return;
} }
@ -40,7 +40,7 @@ inline void changePoint(int k, int x, int c) {
tree[k].w = tree[lc].w + tree[rc].w; tree[k].w = tree[lc].w + tree[rc].w;
} }
// 区间查询 // 区间查询
inline LL queryInterval(int k, int L, int R) { inline LL queryInterval(int k, int L, int R) {
if (tree[k].l >= L && tree[k].r <= R) if (tree[k].l >= L && tree[k].r <= R)
return tree[k].w; return tree[k].w;

10
20240919/CSP常考算法模板/背包问题_01.cpp
View File

@ -17,16 +17,16 @@ int main(){
ios::sync_with_stdio(false); ios::sync_with_stdio(false);
cin.tie(0); cin.tie(0);
cin>>m>>n; //背包容量m和物品数量n cin>>m>>n; //背包容量m和物品数量n
for (int i = 1; i <= n; i++) //在初始化循环变量部分，定义一个变量并初始化 for (int i = 1; i <= n; i++) //在初始化循环变量部分，定义一个变量并初始化
cin>>w[i]>>c[i]; //每个物品的重量和价值 cin>>w[i]>>c[i]; //每个物品的重量和价值
for (int i = 1; i <= n; i++) // f[i][v]表示前i件物品，总重量不超过v的最优价值 for (int i = 1; i <= n; i++) // f[i][v]表示前i件物品，总重量不超过v的最优价值
for (int v = m; v > 0; v--) for (int v = m; v > 0; v--)
if (w[i] <= v) if (w[i] <= v)
f[i][v] = max(f[i-1][v],f[i-1][v-w[i]]+c[i]); f[i][v] = max(f[i-1][v],f[i-1][v-w[i]]+c[i]);
else else
f[i][v] = f[i-1][v]; f[i][v] = f[i-1][v];
cout<<f[n][m]<<endl; // f[n][m]为最优解 cout<<f[n][m]<<endl; // f[n][m]为最优解
return 0; return 0;
} }

8
20240919/CSP常考算法模板/背包问题_多重.cpp
View File

@ -6,14 +6,14 @@ int f[6001];
int n,m,n1; int n,m,n1;
/* /*
【输入样例】 【输入样例】
5 1000 5 1000
80 20 4 80 20 4
40 50 9 40 50 9
30 50 7 30 50 7
40 30 6 40 30 6
20 20 1 20 20 1
【输出样例】 【输出样例】
1040 1040
*/ */
@ -23,12 +23,12 @@ int main() {
int x,y,s,t=1; int x,y,s,t=1;
scanf("%d%d%d",&x,&y,&s); scanf("%d%d%d",&x,&y,&s);
while (s>=t) { while (s>=t) {
v[++n1]=x*t; //相当于n1++; v[n1]=x*t; v[++n1]=x*t; //相当于n1++; v[n1]=x*t;
w[n1]=y*t; w[n1]=y*t;
s-=t; s-=t;
t*=2; t*=2;
} }
//把s以2的指数分堆：1，2，4，…，2^(k-1)，s-2^k+1, //把s以2的指数分堆：1，2，4，…，2^(k-1)，s-2^k+1,
if(s>0) { if(s>0) {
v[++n1]=x*s; v[++n1]=x*s;
w[n1]=y*s; w[n1]=y*s;

6
20240919/CSP常考算法模板/背包问题_完全.cpp
View File

@ -7,14 +7,14 @@ int f[maxm];
int main() int main()
{ {
scanf("%d%d",&m,&n); //背包容量m和物品数量n scanf("%d%d",&m,&n); //背包容量m和物品数量n
for(i=1;i<=n;i++) for(i=1;i<=n;i++)
scanf("%d%d",&w[i],&c[i]); scanf("%d%d",&w[i],&c[i]);
for(i=1;i<=n;i++) for(i=1;i<=n;i++)
for(v=w[i];v<=m;v++) //设 f[v]表示重量不超过v公斤的最大价值 for(v=w[i];v<=m;v++) //设 f[v]表示重量不超过v公斤的最大价值
if(f[v-w[i]]+c[i]>f[v]) if(f[v-w[i]]+c[i]>f[v])
f[v]=f[v-w[i]]+c[i]; f[v]=f[v-w[i]]+c[i];
printf("max=%d\n",f[m]); // f[m]为最优解 printf("max=%d\n",f[m]); // f[m]为最优解
return 0; return 0;
} }