文章目录
算法分析题
第一题：并查集+动态规划
题目的OJ链接
https://www.luogu.com.cn/problem/P1455
题目截图
复杂度分析
这段代码的时间复杂度主要取决于find函数和背包问题算法的复杂度。
时间复杂度O ( n + m log ∗ n + n V ) ，V是预算数，空间复杂度O ( n + V ) O(n+V)O(n+V)。
解题思路
它的主要思路是使用01背包算法来求解问题，在此之前需要先使用并查集维护云朵之间的关系。
- 输入数据，初始化各个数组。
- 使用并查集维护云朵之间的关系，将与某一朵云有搭配关系的云朵合并到同一集合中。
- 使用01背包算法求解问题。对于每个集合，将其对应云朵的价格和价值之和作为01背包的条件进行转移。
- 输出最终答案，即 f [ v o l ] f[vol] f[vol]。
- 该题使用了并查集维护云朵之间的关系，将与某一朵云有搭配关系的云朵合并到同一集合中，之后只考虑每个集合的价格和价值之和，使用01背包算法计算最大价值。
题目注意事项
在编写代码时，需要注意以下几点:
- 数组的维度：在使用动态规划算法时，需要使用一个二维数组来存储状态。在这个问题中，数组的第一维表示物品编号，第二维表示金钱数。
- 初始值：在初始化数组时，需要注意初始值的设置。在这个问题中，对于金钱数为0的情况，价值应该设置为0。
- 状态转移方程：在编写状态转移方程时，需要注意使用01背包算法还是完全背包算法。在这个问题中，由于云朵要搭配起来买才卖，所以应该使用完全背包算法。
- 最终结果：最终结果应该在所有物品和所有金钱数中取最大值。
注意云朵之间的关系，是搭配买还是单独买。
可以记录下购买的云朵的编号，最后输出。
AC代码
import java.util.Scanner;
public class Main {
static int n, m, vol;
static int[] v, w, p;
static int[] f;
//p存储每个云朵的父节点编号
static int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
m = scan.nextInt();
vol = scan.nextInt();
v = new int[n + 1];
w = new int[n + 1];
p = new int[n + 1];
f = new int[vol + 1];
for (int i = 1; i <= n; i++) {
v[i] = scan.nextInt();
w[i] = scan.nextInt();
}
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
int a = scan.nextInt();
int b = scan.nextInt();
int pa = find(a);
int pb = find(b);
if (pa != pb) {
v[pb] += v[pa];
w[pb] += w[pa];
p[pa] = pb;
}
}
for (int i = 1; i <= n; i++)
if (p[i] == i)
for (int j = vol; j >= v[i]; j--)
f[j] = Math.max(f[j], f[j - v[i]] + w[i]);
System.out.println(f[vol]);
}
}
第二题：DFS+贪心
题目的OJ链接
https://www.luogu.com.cn/problem/CF1388D
题目截图
复杂度分析
这段代码的时间复杂度主要由 dfs 函数的执行时间决定。
dfs 函数遍历了整棵树，每个节点只被遍历一次，每个节点的子节点数量最多为 n 个，所以 dfs 函数的时间复杂度为 O(n)。
除了 dfs 函数之外，该代码还有一些其它的操作，如读入数据、输出结果等。这些操作的时间复杂度均为 O(n)。
所以，总的时间复杂度为 O(n)。
空间复杂度上，该代码使用了若干个数组和vector，其中数组a,b,c,d的大小都是 n，vector e 的大小是 n，所以空间复杂度为 O(n)
解题思路
- 使用了DFS 深度优先搜索算法来遍历树上的所有节点。
- 通过读入每个节点的权值和树上父节点的关系来建立树的结构。然后在主函数中，调用 dfs 函数来遍历整棵树。
- 在 dfs 函数中，对于当前遍历到的节点，首先遍历它的子节点，将它的子节点的权值累加到它上面。如果该节点的权值大于等于0，就将其加入到 c 数组中，否则加入到 d 数组中。最后累加遍历到的所有节点的权值和。
- 在主函数中，输出最终结果，先输出权值大于等于0的节点，再输出权值小于0的节点，顺序为从根节点到叶子节点的顺序。
- 求出树上所有节点权值的和，并将所有节点按照权值的大小分类输出。
题目注意事项
用Java编写相同思路代码时超时
AC代码
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5, M = 2e4 + 5, inf = 0x3f3f3f3f, mod = 1e9 + 7;
#define mst(a) memset(a, 0, sizeof(a))
#define reg register
#define pb push_back
ll a[N], ans;
int n, m, b[N];
vector<int> c, d, e[N];
int m1=10005;
void dfs(int u, int fa) {
for (auto v : e[u]) {
if (v == fa) continue;
dfs(v, u);
if (a[v] >= 0) a[u] += a[v];
}
a[u] >= 0 ? c.pb(u) : d.pb(u);
ans += a[u];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
if (~b[i]) e[b[i]].pb(i);
}
for (int i = 1; i <= n; i++)
if (b[i] == -1) dfs(i, 0);
printf("%lld\n", ans);
for (int i : c) printf("%d ", i);
for (int i = d.size() - 1; ~i; i--) printf("%d ", d[i]);
return 0;
}
第三题：欧拉路+哈希+并查集
题目的OJ链接
https://www.luogu.com.cn/problem/P1333
题目截图
复杂度分析
代码主要用哈希表和并查集来处理数据。
-
首先，在读入数据时，对于每一对字符串，都会调用一次哈希表的插入操作。在插入操作中，会在哈希表中寻找这个字符串的位置，如果找到了相同的字符串，则直接返回其位置，否则在哈希表中插入这个字符串。由于哈希表的大小是固定的，所以插入操作的时间复杂度为O(1)。
-
随后，对于每对读入的字符串，会使用并查集维护它们之间的关系。在并查集中，每次询问和合并的时间复杂度均为O(α(n))，其中α(n)是欧拉函数的逆函数，它的值在接近于0，所以可以视作常数。
-
最后，在判断是否存在欧拉回路时，遍历所有点，统计入度为奇数的点的个数。这部分的时间复杂度为O(n)。
-
总的来说，这段代码的时间复杂度为O(n),其中n为读入的字符串对数
解题思路
简化题目：判断给定的一组字符串是否存在欧拉回路。
-
首先，使用哈希表维护所有字符串的编号，并统计每个点的入度。
-
然后，使用并查集维护所有字符串之间的关系，判断它们是否在同一个连通块中。
-
最后，遍历所有点，统计入度为奇数的点的个数。如果存在欧拉回路，则所有点的入度都应该为偶数，否则不存在欧拉回路。
题目注意事项
-
哈希表的大小，如果哈希表的大小不够，可能会造成碰撞，导致程序运行不正常。
-
哈希函数的选择，不同的哈希函数可能会产生不同的结果，需要根据实际情况进行选择。
-
并查集的初始化，并查集的初始化很重要，需要将每个点的父节点都设置为自己。
-
入度统计，在统计入度时，需要将每对字符串都累加一次入度。
-
判断欧拉回路，需要判断所有点都在同一个连通块中且所有点的入度都为偶数，才能说明存在欧拉回路。
AC代码
#include <cstdio>
#include <cstring>
const int N=2e6+5,M=5e5+5,mod=2e6;
const int seed[5]={31,37,131,41};
int dgr[N],fa[M];
int m = 100002;
char s[15];
namespace Hash
{
int cnt,val[N],pos[N];
int GetHash(char *s)
{
int x=0,l=strlen(s);
for(int i=0; i<l; ++i) x=(x+s[i]*seed[i%4])%mod;
return x;
}
int Insert(char *s)
{
int p=GetHash(s);
while(val[p]&&val[p]!=p){
++p;
if(p>=mod) p-=mod;
}
if(val[p]) return pos[p];
val[p]=p;
return pos[p]=++cnt;
}
}
int Find(int x){
return x==fa[x]?x:fa[x]=Find(fa[x]);
}
int main()
{
int p1,p2,r1,r2,t=0;
for(int i=1; i<M; ++i) fa[i]=i;
while(~scanf("%s",s))
{
p1=Hash::Insert(s);
scanf("%s",s);
p2=Hash::Insert(s);
++dgr[p1], ++dgr[p2];
r1=Find(p1), r2=Find(p2);
if(r1!=r2) ++t,fa[r1]=r2;
}
if(t<Hash::cnt-1) {printf("Impossible"); return 0;}
int tot=Hash::cnt; t=0;
for(int i=1; i<=tot; ++i)
if(dgr[i]&1) ++t;
printf(t>2?"Impossible":"Possible");
return 0;
}
第四题：队列+最短路+广搜
题目的OJ链接
https://www.luogu.com.cn/problem/P1685
题目截图
复杂度分析
-
这个程序的时间复杂度主要由 bfs() 函数的复杂度决定。在 bfs() 函数中，我们遍历了所有点的所有出边，因此总共遍历了 m 条边。同时，我们使用了队列进行广度优先搜索，因此队列中最多只会有 n 个点。因此，bfs() 函数的时间复杂度为 O(n+m)。
-
整个程序的时间复杂度为读入数据和 bfs() 函数的复杂度之和，即 O(n+m)。
解题思路
-
这道题的解题思路是使用广度优先搜索（BFS）来求解单源最短路径。
-
我们首先通过读入数据初始化图的结构，并将源点入队。在每次取出队首元素时，遍历它的所有出边，更新终点的f和g值。如果终点的入度为0，将其入队。
-
最后，我们可以得到源点到其他点的最短路径长度和路径条数。最后，输出结果为最短路径长度和路径条数的结合，来得出最终答案。
题目注意事项
- 注意读入数据时的类型转换，输入的数据可能为负数。
- 在添加边时，如果起点和终点相同，应该跳过，避免出现自环。
- 在计算 f 和 g 值时，需要使用模运算来避免爆 int，保证结果在 mod 范围内。
- 在输出结果时，需要再次使用模运算来避免爆 int。
AC代码
#include <iostream>
#include <cstdio>
#include <queue>
#define int long long
using namespace std;
const int wx=100017;
const int mod=10000;
inline int read(){
int sum=0,f=1; char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1; ch=getchar();}
while(ch>='0'&&ch<='9'){sum=(sum<<1)+(sum<<3)+ch-'0'; ch=getchar();}
return sum*f;
}
int num,n,m,s,t,t0;
int f[wx],g[wx],in[wx],head[wx];
struct e{
int nxt,to,dis;
}edge[wx*2];
void add(int from,int to,int dis){
edge[++num].nxt=head[from];
edge[num].to=to;
edge[num].dis=dis;
head[from]=num;
}
queue<int > q;
void bfs(){
q.push(s); g[s]=1;
while(q.size()){
int u=q.front(); q.pop();
for(int i=head[u];i;i=edge[i].nxt){
int v=edge[i].to;
(f[v]+=f[u]+g[u]*edge[i].dis)%=mod;
(g[v]+=g[u])%=mod;
in[v]--;
if(!in[v])q.push(v);
}
}
}
signed main(){
n=read(); m=read(); s=read(); t=read(); t0=read();
for(int i=1;i<=m;i++){
int x,y,z;
x=read(); y=read(); z=read();
if(x==y)continue;
in[y]++;
add(x,y,z);
}
bfs();
printf("%lld\n",(f[t]%mod+(g[t]-1)*t0%mod)%mod);
return 0;
}
第五题：DP+（矩阵）数学方法
题目的OJ链接
https://www.luogu.com.cn/problem/P1004
题目截图
复杂度分析
-
上述代码的时间复杂度为O(n^ 4)。因为其中有四重循环，每重循环的复杂度都为O(n)，所以总的时间复杂度为O(n^ 4)。
-
空间复杂度为O(n^4)，因为其中定义了一个4维的数组dp [ i ] [ j ] [ k ] [ l ]用来存储结果，每一维的大小都是n，所以空间复杂度为O(n^4)。
-
通过上述代码我们可以发现，由于n的大小非常大，所以时间复杂度和空间复杂度都非常大，因此在实际应用中需要优化时间复杂度和空间复杂度，以解决大规模数据问题。
解题思路
使用动态规划来解决问题。
-
首先，它使用了一个4维的数组dp[i][j][k][l]来存储从(i,j)到(k,l)的最大价值。
-
然后，定义了一个状态转移方程,其中，i,j,k,l分别表示四个维度，在转移方程中，通过比较dp[i-1][j][k-1][l],dp[i-1][j][k][l-1],dp[i][j-1][k-1][l],dp[i][j-1][k][l-1]的大小来得到dp[i][j][k][l]的最大值。
-
接着，定义了边界条件，dp[i][j][i][j] = a[i][j]。
-
最后，输出结果，dp[n][n][n][n]。
-
在输入的时候，读入的是每一个点的坐标和值，使用a[i][j]来存储，这样可以避免读入数据的空间浪费。
题目注意事项
- 矩阵链乘积问题本质上是动态规划问题，所以使用DP来解决。
- 在转移时要注意比较上一步的结果
- 输出结果时要注意比较上一步的结果
AC代码
import java.util.Scanner;
public class Main {
static int a[][] = new int[10][10];
static int dp[][][][] = new int[10][10][10][10];
static int tmpx, tmpy, tmpnum, n;
static int max(int a, int b) {
return a > b ? a : b;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
while (true) {
tmpx = sc.nextInt();
tmpy = sc.nextInt();
tmpnum = sc.nextInt();
if (tmpx == 0 && tmpy == 0 && tmpnum == 0)
break;
a[tmpx][tmpy] = tmpnum;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
for (int l = 1; l <= n; l++)
dp[i][j][k][l] = max(max(dp[i - 1][j][k - 1][l], dp[i - 1][j][k][l - 1]),
max(dp[i][j - 1][k - 1][l], dp[i][j - 1][k][l - 1]))
+ (((i == k && j == l) ? 0 : (a[k][l])) + a[i][j]);
System.out.println(dp[n][n][n][n]);
}
}
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
