• 20220720学习反思

    今日进行了upc个人赛第十场，下午学习了一些图论的知识。

    问题 A: 魔法飞毯

    时间限制: 1.000 Sec  内存限制: 128 MB
    提交 状态

    题目描述

    明明在玩魔法飞毯游戏,所有飞毯的形状都是矩形｡她的面前有n个数(均为正整数),她想从中选出两个数作为飞毯的长和宽,使这张飞毯的面积尽量大,问这张最大飞毯的面积是多少?

    输入

    第一行:一个整数n,表示一共有n个数
    第二行:n个正整数

    输出

    一个正整数,表示能够组成的最大飞毯面积

    样例输入 Copy

    5
1 2 3 4 5

    样例输出 Copy

    20

    提示

    对于20%的输入数据,2<=n<=4,其余数字均小于等于10
    对于50%的数据,2<=n<=100,其余数字均小于等于1000
    对于100%的数据,2<=n<=100000,其余数字均小于等于10000

    水题一枚：

    1. #include 
    2.  
    3. using namespace std;
    4. int max1, max2;
    5. int main() {
    6.     int n;
    7.     cin >> n;
    8.     while (n --) {
    9.         int x;
    10.         cin >> x;
    11.         if (x > max1) {
    12.             max2 = max1;
    13.             max1 = x;
    14.         } else if (x > max2) {
    15.             max2 = x;
    16.         }
    17.     }
    18.     cout << max1 * max2 << endl;
    19.     return 0;
    20. }
    21. /**************************************************************
    22.     Problem: 17415
    23.     User: 2021QDU013
    24.     Language: C++
    25.     Result: 正确
    26.     Time:63 ms
    27.     Memory:2024 kb
    28. ****************************************************************/

    问题 B: 排球比赛

    时间限制: 1.000 Sec  内存限制: 128 MB
    提交 状态

    题目描述

    近年来,排球这项体育运动由于深受大家的喜爱而变得越来越普及｡排球比赛的规则是这样的,两队球员隔网相对,每队应由6名球员组成,另外还可以有6名替补球员｡排球比赛通常采用五局三胜制,首4局以先得25分者为胜方｡若双方打成24平手,则应继续作赛,直至其中一方先多得2分为胜;但在决胜局中,则先达15分的一方为胜方,若双方打成14平手,则应继续作赛,直至其中一方先多得2分为胜｡

    周末,小图同学和小灵同学相约去看球,比赛进行的非常激烈,但是他们两个都是高度近视,看不清远处屏幕上的比分｡细心的小图记录下了整场的比赛情况,比如这场比赛的情况是(其中A表示A队得一分,B表示B队得一分):AAAABBBBABAAABABABBABBBAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBABAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAABABABABABABABABABABABABABABABABABABABABABABABABBBAAAAAAABBAAAAAAAAE

    在排球比赛的赛制要求下,目前每轮的比分是25:12､1:25､26:24､24:26和15:2,总比分为3:2,A队赢得本场比赛｡

    你的程序要根据小图同学记录下来的整场比赛信息,统计出两支队伍最终的总比分结果｡

    输入

    输入包含一行字符串，包含本场比赛的全部信息。
    该行字符串中的字符数量少于等于300个。
    字符串由大写的A、B和E组成。
    其中E表示整场比赛结束。程序应当忽略E之后的所有内容。

    输出

    输出只有一行，为整场比赛的最终比分榜单。两个比分之间用英文冒号隔开。

    样例输入 Copy

    【样例1】
AAAABBBBABAAABABABBABBBAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBABAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAABABABABABABABABABABABABABABABABABABABABABABABABBBAAAAAAABBAAAAAAAAE
【样例2】

    样例输出 Copy

    【样例1】
3:2
【样例2】
0:3

    一道模拟题目，注意分清楚条件进行判断，第几局结束比赛需要注意

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main() {
    6.     string op;
    7.     cin >> op;
    8.     int cnt1 = 0, cnt2 = 0;
    9.     int st1 = 0, st2 = 0;
    10.     for (int i = 0; i < op.size() - 1; i++) {
    11.          
    12.         if (op[i] == 'A') st1++;
    13.         if (op[i] == 'B') st2++;
    14.         //cout << cnt1 << ' ' << st1 << ' ' << cnt2 << ' ' << st2 << endl;
    15.         if (cnt1 == 2 && cnt2 == 2) { //决胜局 14i
    16.             if (st1 >= 14 && st2 >= 14) {
    17.                 if (st1 - st2 == 2) {
    18.                     cnt1 ++;
    19.                     st1 = 0;
    20.                     st2 = 0;
    21.                     break;
    22.                 } else if (st2 - st1 == 2) {
    23.                     cnt2 ++;
    24.                     st1 = 0;
    25.                     st2 = 0;
    26.                     break;
    27.                 }
    28.             } else if (st1 == 15) {
    29.                 cnt1 ++;
    30.                 break;
    31.             } else if (st2 == 15) {
    32.                 cnt2 ++;
    33.                 break;
    34.             }
    35.         } else {
    36.             if (st1 >= 24 && st2 >= 24) {
    37.                 if (st1 - st2 == 2) {
    38.                     cnt1 ++;
    39.                     st1 = 0;
    40.                     st2 = 0;
    41.                 } else if (st2 - st1 == 2) {
    42.                     cnt2 ++;
    43.                     st1 = 0;
    44.                     st2 = 0;
    45.                 }
    46.             } else if (st1 == 25) {
    47.                 cnt1 ++;
    48.                 st1 = 0;
    49.                 st2 = 0;
    50.             } else if (st2 == 25) {
    51.                 cnt2 ++;
    52.                 st1 = 0;
    53.                 st2 = 0;
    54.             }
    55.         }
    56.     }
    57.     cout << cnt1 << ':' << cnt2 << endl;
    58.     return 0;
    59. }
    60. /**************************************************************
    61.     Problem: 17416
    62.     User: 2021QDU013
    63.     Language: C++
    64.     Result: 正确
    65.     Time:9 ms
    66.     Memory:2024 kb
    67. ****************************************************************/

    问题 C: 巨石阵

    时间限制: 1.000 Sec  内存限制: 128 MB
    提交 状态

    题目描述

    大嘴猴在森林里发现了一个神奇的排成一排的巨石阵。每晚在每块巨石上都会出现若干根好吃的香蕉，当太阳升起时，所有香蕉就会消失。大嘴猴发现一个规律，如果它拿走相邻两块巨石上的香蕉，那么巨石阵很久都不会出产香蕉。大嘴猴想知道，在每晚都能吃到香蕉的情况下，一晚能拿走的最多的香蕉数量。

    输入

    输入共两行
    第一行1个正整数n，表示巨石的数量第二行n个非负整数，以空格分隔，表示每块巨石上的香蕉数量stone[i]

    输出

    输出共一行
    第一行1个整数，表示大嘴猴一晚最多能拿走的香蕉数量

    样例输入 Copy

    【样例1】
4
5 3 7 2
【样例2】
6
3 9 7 2 5 1

    样例输出 Copy

    【样例1】
12
【样例2】
15

    提示

    样例1解释：拿走1号巨石上的香蕉 (香蕉数量 = 5) ，然后拿走3号巨石上的香蕉 (香蕉数量 = 7)。一晚能拿走香蕉的最高数量 = 5 + 7 = 12 。

    样例2解释：拿走1号巨石上的香蕉(香蕉数量 = 3), 然后拿走3号巨石上的香蕉 (香蕉数量 = 7)，然后拿走5号巨石上的香蕉 (香蕉数量 = 5)。一晚能拿走香蕉的最高数量 = 3 + 7 + 5 = 15 。

    数据范围与约定0

    一道dp的题目，相邻两次不能选，然后dp[i][j] 表示的：i是第几块石头， j表示的是选还是不选。

    然后dp[i][1] = dp[i - 1][0]; // 选

    dp[i][0] = max(dp[i - 1][0], dp[i - 1][1])// 不选的时候由两种状态转移过来

    1. #include 
    2. #define int long long 
    3.  
    4. using namespace std;
    5. const int N = 1010;
    6. int q[N];
    7. int dp[N][3];
    8. signed main() {
    9.     int n;
    10.     cin >> n;
    11.     for (int i = 1; i <= n; i++) cin >> q[i];
    12.     for (int i = 1; i <= n; i++) {
    13.         dp[i][1] = dp[i - 1][0] + q[i];
    14.         dp[i][0] = max(dp[i - 1][1], dp[i - 1][0]); //选不选都可以
    15.     }
    16.      
    17.     cout << max(dp[n][1], dp[n][0]);
    18.      
    19. }
    20.  
    21. /**************************************************************
    22.     Problem: 17417
    23.     User: 2021QDU013
    24.     Language: C++
    25.     Result: 正确
    26.     Time:8 ms
    27.     Memory:2056 kb
    28. ****************************************************************/

    问题 H: NYG的背包

    时间限制: 1.000 Sec  内存限制: 128 MB
    提交 状态

    题目描述

    扎扙扇有一个神奇的背包，每放进去一个物品，背包的体积就会变大。
    也就是说，每放进一个物品，背包会被占用一定的体积，但是紧接着背包的总体积又会增大一定的值（注意是在放入物品后背包总体积才增大）。
    扎扙扇发觉这个背包十分好用，于是不由自主地想到了一个问题。
    现在给出背包初始容量V以及n个物品，每一个物品两个值a，b，分别表示物品所占体积和放入背包后背包增大的体积。
    扎扙扇想知道能否把所有物品装进去？
    因为扎扙扇比较老实，这么简单的问题自然装作不会做的样子。
    于是他来请教你。

    输入

    输入包含多组数据。
    第一行一个数扔表示数据组数。
    对于每组数据，第一行两个数n,h，接下来扮行每行两个数a,b表示物品所占体积和放入背包后背包增大的体积。

    输出

    对于每一组数据，如果能把所有物品装进去，输出Yes，否则输出No（不包含引号）

    样例输入 Copy

    2
9 16025
9347 22431
24033 16840
29117 20429
10501 19350
32743 23260
15985 25029
19262 7012
12399 8009
19838 1154
9 17593
5569 26966
26492 23437
26690 10777
1187 19715
854 11190
9086 12447
5700 16106
30244 17186
12690 7604

    样例输出 Copy

    No
Yes

    提示

    提交状态

     一道很有意思的贪心的题目，两次排序会导致T，只能排一次，然后就要考虑是一种怎么样的排序方法，如果都能让体积增大，就把体积小的放前边，如果会让体积变小，就把让体积变小多的放前边，否则就让增长的放前边。

    1. #include 
    2. #include 
    3. #include 
    4. #define int long long 
    5. using namespace std;
    6.  
    7. inline int read() {
    8.     int res = 0, flag = 1;
    9.     char c = getchar();
    10.     while (!isdigit(c)) {
    11.         if (c == '-') {
    12.             flag = -1;
    13.         }
    14.         c = getchar();
    15.     }
    16.     while (isdigit(c)) {
    17.         res = (res << 1) + (res << 3) + (c ^ 48);
    18.         c = getchar();
    19.     }
    20.      
    21.     return res * flag;
    22. }
    23. typedef pair<int,int> PII;
    24. const int N = 1e6 + 10;
    25. PII add[N];
    26.  
    27. int n, v;
    28.  
    29. bool cmp(PII a, PII b) {
    30.     if (a.second - a.first >= 0 && b.second - b.first >= 0) return a.first< b.first;
    31.     if (a.second - a.first < 0 && b.second - b.first < 0) return a.second > b.second;
    32.     return a.second - a.first >= 0;
    33. }
    34.  
    35.  
    36. void solved() {
    37.     //memset(add, 0, sizeof add);
    38.     cin >> n >> v;
    39.     for (int i = 0; i < n; i++) {
    40.         int x, y;
    41.         x = read();
    42.         y = read();
    43.         add[i] = {x, y};
    44.     }
    45.     sort(add, add + n, cmp);
    46.     // for (int i = 0; i < n; i++) {
    47.         // cout << add[i].first << ' ' << add[i].second << endl;
    48.     // }
    49.     for (int i = 0; i < n; i++) {
    50.         if (add[i].first > v) {
    51.             cout << "No" << "\n";
    52.             return;
    53.         }
    54.         v -= add[i].first;
    55.         v += add[i].second;
    56.     }
    57.     cout << "Yes" << "\n";
    58.     return ;
    59.      
    60. }
    61. signed main() {
    62.     int _;
    63.     cin >> _;
    64.     while (_ --) {
    65.         solved();
    66.     }
    67.      
    68.     return 0;
    69. }
    70.  
    71. /**************************************************************
    72.     Problem: 15376
    73.     User: 2021QDU013
    74.     Language: C++
    75.     Result: 正确
    76.     Time:1472 ms
    77.     Memory:17652 kb
    78. ****************************************************************/

    然后就是学习了一些最短路的算法，

    观光奶牛

    给定一张 LL 个点、PP 条边的有向图，每个点都有一个权值 f[i]f[i]，每条边都有一个权值 t[i]t[i]。

    求图中的一个环，使“环上各点的权值之和”除以“环上各边的权值之和”最大。

    输出这个最大值。

    注意：数据保证至少存在一个环。

    输入格式

    第一行包含两个整数 LL 和 PP。

    接下来 LL 行每行一个整数，表示 f[i]f[i]。

    再接下来 PP 行，每行三个整数 a，b，t[i]a，b，t[i]，表示点 aa 和 bb 之间存在一条边，边的权值为 t[i]t[i]。

    输出格式

    输出一个数表示结果，保留两位小数。

    数据范围

    2≤L≤10002≤L≤1000,
    2≤P≤50002≤P≤5000,
    1≤f[i],t[i]≤10001≤f[i],t[i]≤1000

    输入样例：

    1. 5 7
    2. 30
    3. 10
    4. 10
    5. 5
    6. 10
    7. 1 2 3
    8. 2 3 2
    9. 3 4 5
    10. 3 5 2
    11. 4 5 5
    12. 5 1 3
    13. 5 2 2

    输出样例：

    6.00
    难度：中等
    时/空限制：1s / 64MB
    总通过数：3995
    总尝试数：7432
    来源：《算法竞赛进阶指南》
    算法标签

    这是属于01规划问题，利用了二分和spfa的知识点，每次二分check一下是否存在环，如果存在环的话就让l= mid。

    所以先反思一下spfa求负环的思路，首先将所有节点入队列，然后把每一个节点设置为true；

    然后开始进行spfa, 运用循环对了来储存元素，然后每次取出对头，用链式前向星对于队列进行一个便利，然后如果距离发生更新的话，就让cnt ++， 然后判断一下这个节点的cnt如果大于等于n也就是意味着没有环的情况下存在n + 1条点，这样的话我们就直接返回true， 表示存在负环，如果没有的话，最后return false；

    代码入下：这个是直接用的stl

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. using namespace std;
    7.  
    8. const int N = 2010, M = 10010;
    9.  
    10. int n, m;
    11. int h[N], w[M], e[M], ne[M], idx;
    12. int dist[N], cnt[N];
    13. bool st[N];
    14.  
    15. void add(int a, int b, int c)
    16. {
    17.     e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
    18. }
    19.  
    20. bool spfa()
    21. {
    22.     queue<int> q;
    23.  
    24.     for (int i = 1; i <= n; i ++ )
    25.     {
    26.         st[i] = true;
    27.         q.push(i);
    28.     }
    29.  
    30.     while (q.size())
    31.     {
    32.         int t = q.front();
    33.         q.pop();
    34.  
    35.         st[t] = false;
    36.  
    37.         for (int i = h[t]; i != -1; i = ne[i])
    38.         {
    39.             int j = e[i];
    40.             if (dist[j] > dist[t] + w[i])
    41.             {
    42.                 dist[j] = dist[t] + w[i];
    43.                 cnt[j] = cnt[t] + 1;
    44.  
    45.                 if (cnt[j] >= n) return true;
    46.                 if (!st[j])
    47.                 {
    48.                     q.push(j);
    49.                     st[j] = true;
    50.                 }
    51.             }
    52.         }
    53.     }
    54.  
    55.     return false;
    56. }
    57.  
    58. int main()
    59. {
    60.     scanf("%d%d", &n, &m);
    61.  
    62.     memset(h, -1, sizeof h);
    63.  
    64.     while (m -- )
    65.     {
    66.         int a, b, c;
    67.         scanf("%d%d%d", &a, &b, &c);
    68.         add(a, b, c);
    69.     }
    70.  
    71.     if (spfa()) puts("Yes");
    72.     else puts("No");
    73.  
    74.     return 0;
    75. }

    所以言归正传回到这道题目上。

    环上各点的权值之和”除以“环上各边的权值之和”最大

    设答案为 ans。

    二分答案，设当前二分值为 mid。

    设一个环 SS 的边权为 t1,t2,t3…t1,t2,t3…，点权为 f1,f2,f3…f1,f2,f3…
    若 mid<=ans，即存在一个环SS使得 mid<=∑fi∑ti，变换一下：∑(mid∗ti−fi)<=0

    否则，则 mid>ans
    每次 check的时候，一条 uu 指向 vv，边权为 ww 的边权变为：

    w∗mid−fu。我们只需检查这个图是否存在负环即可。

    所以代码实现起来是这样的：

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6. const int N = 1010, M = 5010;
    7. int h[N], ne[M], wt[M], idx, e[M];
    8. int wf[N];
    9. bool st[N];
    10. int cnt[N];
    11. double dist[N];
    12. int q[N];
    13. int n, m;
    14. void add(int a, int b, int c) {
    15.     e[idx] = b,ne[idx] = h[a], wt[idx] = c, h[a] = idx ++;
    16. }
    17.  
    18. bool check(double mid)
    19. {
    20.     memset(dist, 0, sizeof dist);
    21.     memset(st, 0, sizeof st);
    22.     memset(cnt, 0, sizeof cnt);
    23.  
    24.     int hh = 0, tt = 0;
    25.     for (int i = 1; i <= n; i ++ )
    26.     {
    27.         q[tt ++ ] = i;
    28.         st[i] = true;
    29.     }
    30.  
    31.     while (hh != tt)
    32.     {
    33.         int t = q[hh ++ ];
    34.         if (hh == N) hh = 0;
    35.         st[t] = false;
    36.  
    37.         for (int i = h[t]; ~i; i = ne[i])
    38.         {
    39.             int j = e[i];
    40.             if (dist[j] < dist[t] + wf[t] - mid * wt[i])
    41.             {
    42.                 dist[j] = dist[t] + wf[t] - mid * wt[i];
    43.                 cnt[j] = cnt[t] + 1;
    44.                 if (cnt[j] >= n) return true;
    45.                 if (!st[j])
    46.                 {
    47.                     q[tt ++ ] = j;
    48.                     if (tt == N) tt = 0;
    49.                     st[j] = true;
    50.                 }
    51.             }
    52.         }
    53.     }
    54.  
    55.     return false;
    56. }
    57.  
    58. int main() {
    59.     memset(h, -1, sizeof h);
    60.     cin >> n >> m;
    61.     for (int i = 1; i <= n; i++) cin >> wf[i];
    62.     for (int i = 1; i <= m; i++) {
    63.         int a, b, c;
    64.         cin >> a >> b >> c;
    65.         add(a, b, c);
    66.     }
    67.     
    68.     double l = 0, r = 1e6;
    69.     while (r - l > 1e-4) {
    70.         double mid = (l + r) / 2;
    71.         if (check(mid)) l = mid;
    72.         else r = mid;
    73.     }
    74.     
    75.     printf("%.2lf", l);
    76.     return 0;
    77. }
    78.  
    79.  
    80.  
    81.  
    82.  
    83.  
    84.  
    85.  
    86.

    最后又写了一道单源最短路的问题，也比较有意思，涉及到对应点的身份地位的问题：

    903. 昂贵的聘礼

    ​​​​​​​

    年轻的探险家来到了一个印第安部落里。

    在那里他和酋长的女儿相爱了，于是便向酋长去求亲。

    酋长要他用 1000010000 个金币作为聘礼才答应把女儿嫁给他。

    探险家拿不出这么多金币，便请求酋长降低要求。

    酋长说：”嗯，如果你能够替我弄到大祭司的皮袄，我可以只要 80008000 金币。如果你能够弄来他的水晶球，那么只要 50005000 金币就行了。”

    探险家就跑到大祭司那里，向他要求皮袄或水晶球，大祭司要他用金币来换，或者替他弄来其他的东西，他可以降低价格。

    探险家于是又跑到其他地方，其他人也提出了类似的要求，或者直接用金币换，或者找到其他东西就可以降低价格。

    不过探险家没必要用多样东西去换一样东西，因为不会得到更低的价格。

    探险家现在很需要你的帮忙，让他用最少的金币娶到自己的心上人。

    另外他要告诉你的是，在这个部落里，等级观念十分森严。

    地位差距超过一定限制的两个人之间不会进行任何形式的直接接触，包括交易。

    他是一个外来人，所以可以不受这些限制。

    但是如果他和某个地位较低的人进行了交易，地位较高的的人不会再和他交易，他们认为这样等于是间接接触，反过来也一样。

    因此你需要在考虑所有的情况以后给他提供一个最好的方案。

    为了方便起见，我们把所有的物品从 11 开始进行编号，酋长的允诺也看作一个物品，并且编号总是 11。

    每个物品都有对应的价格 PP，主人的地位等级 LL，以及一系列的替代品 TiTi 和该替代品所对应的”优惠” ViVi。

    如果两人地位等级差距超过了 MM，就不能”间接交易”。

    你必须根据这些数据来计算出探险家最少需要多少金币才能娶到酋长的女儿。

    输入格式

    输入第一行是两个整数 M，NM，N，依次表示地位等级差距限制和物品的总数。

    接下来按照编号从小到大依次给出了 NN 个物品的描述。

    每个物品的描述开头是三个非负整数 P、L、XP、L、X，依次表示该物品的价格、主人的地位等级和替代品总数。

    接下来 XX 行每行包括两个整数 TT 和 VV，分别表示替代品的编号和”优惠价格”。

    输出格式

    输出最少需要的金币数。

    数据范围

    1≤N≤1001≤N≤100,
    1≤P≤100001≤P≤10000,
    1≤L,M≤N1≤L,M≤N,
    0≤X

    输入格式

    1. 1 4
    2. 10000 3 2
    3. 2 8000
    4. 3 5000
    5. 1000 2 1
    6. 4 200
    7. 3000 2 1
    8. 4 200
    9. 50 2 0

    输出格式

    5250

    这道题目在做的时候，我们设立一个虚拟源点，我们让g[0][i]由0指向i代表着以0为起点，i为终点，边的权值代表着购买它需要的代价。

    然后我们在对它进行处理的时候，首先建立图，由于我们一定要买1号点上的东西，所以我们循环从1的等级减m到1的等级为止。

    然后 我们每次循环都对i到i+ m代表着进行最短路的范围。

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. using namespace std;
    7. const int N = 1010;
    8.  
    9. int n, m;
    10. int w[N][N], level[N];
    11. int dist[N];
    12. bool st[N];
    13.  
    14. int dijkstra(int down, int up) {
    15.     memset(dist, 0x3f, sizeof dist);
    16.     memset(st, 0, sizeof st);
    17.     
    18.     dist[0] = 0;
    19.     for (int i = 1; i <= n + 1; i++) {
    20.         int t = -1;
    21.         for (int j = 0; j <= n; j++) {
    22.             if (!st[j] && (t == -1 || dist[t] > dist[j])) {
    23.                 t = j;
    24.             }
    25.         }
    26.         st[t] = true;
    27.         for (int j = 1; j <= n; j++) {
    28.             if (level[j] >= down && level[j] <= up) {
    29.                 dist[j] = min(dist[j], dist[t] + w[t][j]);
    30.             }
    31.         }
    32.     }
    33.     
    34.     return dist[1];
    35. }
    36. int main() {
    37.     cin >> m >> n;
    38.  
    39.     memset(w, 0x3f, sizeof w);
    40.     for (int i = 1; i <= n; i ++ ) w[i][i] = 0;
    41.  
    42.     for (int i = 1; i <= n; i ++ )
    43.     {
    44.         int price, cnt;
    45.         cin >> price >> level[i] >> cnt;
    46.         w[0][i] = min(price, w[0][i]);
    47.         while (cnt -- )
    48.         {
    49.             int id, cost;
    50.             cin >> id >> cost;
    51.             w[id][i] = min(w[id][i], cost);
    52.         }
    53.     }
    54.  
    55.     int res = 0x3f3f3f3f;
    56.     for (int i = level[1] - m; i <= level[1]; i ++ ) res = min(res, dijkstra(i, i + m));
    57.     // cout << w[0][1] << endl;
    58.     // cout << w[4][2] << endl;
    59.     // cout << w[4][3] << endl;
    60.     cout << res << endl;
    61.  
    62.     return 0;
    63.  
    64. }

    最后的话，感觉自己状态不好，不知道为什么，希望一切好起来吧。

  • 相关阅读:
    SpringBoot 集成 Netty
    用vscode platform编写esp32连接dht20传感器 数据一直读取失败
    行为学派 进化计算
    前端如何用mockjs插件模拟接口调用
    操作系统的分类
    基于Vue+Element-Ui开发的月日组件，可以选择月份和天数小插件（新版本）
    LVS集群
    4.1 数据仓库基础与Apache Hive入门
    如何学习？今天聊聊关于学习
    期货择时策略-基于Hurst指数的分型策略研究
  • 原文地址：https://blog.csdn.net/beloved_yu/article/details/125899943