当前位置：网站首页>2021年团体程序设计天梯赛-模拟赛
2021年团体程序设计天梯赛-模拟赛
2022-06-29 09:23:00 【陌陌623】
文章目录
感觉有就用点个赞叭~
代码比较简介，注释比较少，不懂的伙计可以私聊或者留言
L1-1 宇宙无敌大招呼 (5 分)
据说所有程序员学习的第一个程序都是在屏幕上输出一句“Hello World”，跟这个世界打个招呼。作为天梯赛中的程序员，你写的程序得高级一点，要能跟任意指定的星球打招呼。
输入格式：
输入在第一行给出一个星球的名字S，是一个由不超过7个英文字母组成的单词，以回车结束。
输出格式：
在一行中输出Hello S，跟输入的S星球打个招呼。
输入样例：
Mars
输出样例：
Hello Mars
Code
#include <iostream>
using namespace std;
int main()
{
string s;
cin >> s;
cout << "Hello " << s;
return 0;
}
L1-2 考试周 (5 分)
考试周快到了，浙江大学的电子屏又调皮了…… 本题请你帮小编写一个自动倒计时的程序，对给定的日期（例如“腊八”就对应 8）和倒计时天数（例如电子屏上的“四天之后”就对应 4），自动调整公式里的分母（例如 8/2=4 里面的那个 2）。
输入格式：
输入在一行中给出两个正整数：A 是给定的日期，不超过 30；B 是倒计时天数，不超过 10。
输出格式：
在一行中输出公式 A/X=B，其中 X 是满足等式的数字，输出时保留小数点后 1 位即可。
输入样例：
8 3
输出样例：
8/2.7=3
Code
#include <iostream>
using namespace std;
int main()
{
int x, y;
cin >> x >> y;
printf("%d/%.1f=%d", x, 1.0 * x / y, y);
return 0;
}
L1-3 真的恭喜你 (10 分)
当别人告诉你自己考了 x 分的时候，你要回答说：“恭喜你考了 x 分！”比如小明告诉你他考了90分，你就用汉语拼音打出来 gong xi ni kao le 90 fen!。
但是如果小明没考好，比如只考了 20 分，你也“恭喜”人家就不对了。这时候你应该安慰他说：“考了 20 分别泄气！”用汉语拼音写出来就是 kao le 20 fen bie xie qi!。
输入格式：
输入在一行里给出一位小朋友的分数。这个分数是一个 0 到 100 之间的整数。
输出格式：
在一行中输出你对这位小朋友说的话。如果人家考到不低于 90 分，就说 gong xi ni kao le X fen!；如果不到 90 分，就说 kao le X fen bie xie qi!。其中 X 是小朋友输入的分数。
输入样例 1：
95
输出样例 1：
gong xi ni kao le 95 fen!
输入样例 2：
89
输出样例 2：
kao le 89 fen bie xie qi!
简单判断题
Code
#include <iostream>
using namespace std;
int main()
{
int x;
cin >> x;
if (x >= 90)
printf("gong xi ni kao le %d fen!", x);
else
printf("kao le %d fen bie xie qi!", x);
return 0;
}
L1-4 Cassels方程 (10 分)
Cassels方程是一个在数论界产生了巨大影响的不定方程：x2+y2+z2=3xyz。该方程有无穷多自然数解。
本题并不是要你求解这个方程，只是判断给定的一组 (x,y,z) 是不是这个方程的解。
输入格式：
输入在第一行给出一个不超过 10 的正整数 N，随后 N 行，每行给出 3 个正整数 0<x≤y≤z≤1000。
输出格式：
对于每一组输入，如果是一组解，就在一行中输出 Yes，否则输出 No。
输入样例：
2
1 1 1
5 6 7
输出样例：
Yes
No
Code
一行代码完事
#include <iostream>
using namespace std;
int main()
{
int N;
cin >> N;
int a, b, c;
while (N--)
{
cin >> a >> b >> c;
cout << (a * a + b * b + c * c == a * b * c * 3 ? "Yes\n" : "No\n");
}
return 0;
}
L1-5 6翻了 (15 分)
“666”是一种网络用语，大概是表示某人很厉害、我们很佩服的意思。最近又衍生出另一个数字“9”，意思是“6翻了”，实在太厉害的意思。如果你以为这就是厉害的最高境界，那就错啦 —— 目前的最高境界是数字“27”，因为这是 3 个 “9”！
本题就请你编写程序，将那些过时的、只会用一连串“6666……6”表达仰慕的句子，翻译成最新的高级表达。
输入格式：
输入在一行中给出一句话，即一个非空字符串，由不超过 1000 个英文字母、数字和空格组成，以回车结束。
输出格式：
从左到右扫描输入的句子：如果句子中有超过 3 个连续的 6，则将这串连续的 6 替换成 9；但如果有超过 9 个连续的 6，则将这串连续的 6 替换成 27。其他内容不受影响，原样输出。
输入样例：
it is so 666 really 6666 what else can I say 6666666666
输出样例：
it is so 666 really 9 what else can I say 27
题解
如果一个字符串一个字符串的输入 会有点过不去 有这样一种情况：全是空格
故需要将一行全部输入进去 然后循环判断
Code
#include <iostream>
using namespace std;
int main()
{
string s;
getline(cin, s);
for (int i = 0; i < (int)s.size();)
{
if (s[i] == '6')
{
int j = i;
string t = "";
while (j < (int)s.size() && s[j] == '6')
t += s[j], j++;
int len = j - i;
if (len <= 3)
cout << t;
else if (len <= 9)
cout << "9";
else
cout << "27";
i = j;
}
else
cout << s[i++];
}
return 0;
}
L1-6 不变初心数 (15 分)
不变初心数是指这样一种特别的数，它分别乘 2、3、4、5、6、7、8、9 时，所得乘积各位数之和却不变。例如 18 就是这样的数：18 的 2 倍是 36，3+6=9；18 的 3 倍是 54，5+4=9；…… 18 的 9 倍是 162，1+6+2=9。对于 18 而言，9 就是它的初心。本题要求你判断任一个给定的数是否有不变的初心。
输入格式：
输入在第一行中给出一个正整数 N（≤ 100）。随后 N 行，每行给出一个不超过 105 的正整数。
输出格式：
对每个给定的数字，如果它有不变的初心，就在一行中输出它的初心；否则输出 NO。
输入样例：
4
18
256
99792
88672
输出样例：
9
NO
36
NO
题解
就是求出 x位的 数的和
然后判断
代码也很简明：
Code
#include <iostream>
using namespace std;
int x;
int get(int t)
{
int sum = 0;
while (t)
{
sum += t % 10;
t /= 10;
}
return sum;
}
int f()
{
int s = get(2 * x);
for (int i = 3; i <= 9; i++)
{
if (s != get(i * x))
return 0;
}
return s;
}
int main()
{
int N;
cin >> N;
while (N--)
{
cin >> x;
int st = f();
if (st)
cout << st;
else
cout << "NO";
cout << endl;
}
return 0;
}
L1-7 整除光棍 (20 分)
这里所谓的“光棍”，并不是指单身汪啦~ 说的是全部由1组成的数字，比如1、11、111、1111等。传说任何一个光棍都能被一个不以5结尾的奇数整除。比如，111111就可以被13整除。 现在，你的程序要读入一个整数x，这个整数一定是奇数并且不以5结尾。然后，经过计算，输出两个数字：第一个数字s，表示x乘以s是一个光棍，第二个数字n是这个光棍的位数。这样的解当然不是唯一的,题目要求你输出最小的解。
提示：一个显然的办法是逐渐增加光棍的位数，直到可以整除x为止。但难点在于，s可能是个非常大的数 —— 比如，程序输入31，那么就输出3584229390681和15，因为31乘以3584229390681的结果是111111111111111，一共15个1。
输入格式：
输入在一行中给出一个不以5结尾的正奇数x（<1000）。
输出格式：
在一行中输出相应的最小的s和n，其间以1个空格分隔。
输入样例：
31
输出样例：
3584229390681 15
题解
或许第一次做不是那么容易想
相当于模拟了一遍除法：
假设除数是x
被除数是好多个1，具体多少个一开始不知道，但是可以知道 ，最小的被除数是有几个1 因为只有被除数比除数大才有可能整除
首先得到有可能的最小的被除数
然后开始除就可以了，模拟除法：
- 当前的被除数/x = 这一位的商
- 下一次的被除数 = 当前的被除数%x，由于如果不是整除还需要从最初的被除数哪里落下来一个1，所以*10+1
- 知道可以整除为止
Code
#include <iostream>
using namespace std;
int main()
{
int x;
int cnt = 0, ans = 0;
cin >> x;
while (ans < x)
{
ans = ans * 10 + 1;
cnt++;
}
while (1)
{
cout << ans / x;
cout << ans << endl;
if (ans == 1)
break;
cnt++;
}
cout << " ";
cout << cnt;
return 0;
}
L1-8 编程团体赛 (20 分)
编程团体赛的规则为：每个参赛队由若干队员组成；所有队员独立比赛；参赛队的成绩为所有队员的成绩和；成绩最高的队获胜。
现给定所有队员的比赛成绩，请你编写程序找出冠军队。
输入格式：
输入第一行给出一个正整数 N（≤104），即所有参赛队员总数。随后 N 行，每行给出一位队员的成绩，格式为：队伍编号-队员编号 成绩，其中队伍编号为 1 到 1000 的正整数，队员编号为 1 到 10 的正整数，成绩为 0 到 100 的整数。
输出格式：
在一行中输出冠军队的编号和总成绩，其间以一个空格分隔。注意：题目保证冠军队是唯一的。
输入样例：
6
3-10 99
11-5 87
102-1 0
102-3 100
11-9 89
3-2 61
输出样例：
11 176
题解
记录一下 队伍 - 分数 即可
为了方便直接用map搞就行
map<string,int> 类型
队伍编号直接截取：id.substr(0, id.find('-'));
在读入的过程中记录最大值即可
Code
#include <iostream>
#include <map>
using namespace std;
int main()
{
int N, x, maxt = 0;
cin >> N;
string id, ans;
map<string, int> rap;
while (N--)
{
cin >> id >> x;
string t = id.substr(0, id.find('-'));
rap[t] += x;
if (rap[t] > maxt)
maxt = rap[t], ans = t;
}
cout << ans << ' ' << maxt;
return 0;
}
L2-1 彩虹瓶 (25 分)
彩虹瓶的制作过程（并不）是这样的：先把一大批空瓶铺放在装填场地上，然后按照一定的顺序将每种颜色的小球均匀撒到这批瓶子里。
假设彩虹瓶里要按顺序装 N 种颜色的小球（不妨将顺序就编号为 1 到 N）。现在工厂里有每种颜色的小球各一箱，工人需要一箱一箱地将小球从工厂里搬到装填场地。如果搬来的这箱小球正好是可以装填的颜色，就直接拆箱装填；如果不是，就把箱子先码放在一个临时货架上，码放的方法就是一箱一箱堆上去。当一种颜色装填完以后，先看看货架顶端的一箱是不是下一个要装填的颜色，如果是就取下来装填，否则去工厂里再搬一箱过来。
如果工厂里发货的顺序比较好，工人就可以顺利地完成装填。例如要按顺序装填 7 种颜色，工厂按照 7、6、1、3、2、5、4 这个顺序发货，则工人先拿到 7、6 两种不能装填的颜色，将其按照 7 在下、6 在上的顺序堆在货架上；拿到 1 时可以直接装填；拿到 3 时又得临时码放在 6 号颜色箱上；拿到 2 时可以直接装填；随后从货架顶取下 3 进行装填；然后拿到 5，临时码放到 6 上面；最后取了 4 号颜色直接装填；剩下的工作就是顺序从货架上取下 5、6、7 依次装填。
但如果工厂按照 3、1、5、4、2、6、7 这个顺序发货，工人就必须要愤怒地折腾货架了，因为装填完 2 号颜色以后，不把货架上的多个箱子搬下来就拿不到 3 号箱，就不可能顺利完成任务。
另外，货架的容量有限，如果要堆积的货物超过容量，工人也没办法顺利完成任务。例如工厂按照 7、6、5、4、3、2、1 这个顺序发货，如果货架够高，能码放 6 只箱子，那还是可以顺利完工的；但如果货架只能码放 5 只箱子，工人就又要愤怒了……
本题就请你判断一下，工厂的发货顺序能否让工人顺利完成任务。
输入格式：
输入首先在第一行给出 3 个正整数，分别是彩虹瓶的颜色数量 N（1<N≤103）、临时货架的容量 M（<N）、以及需要判断的发货顺序的数量 K。
随后 K 行，每行给出 N 个数字，是 1 到N 的一个排列，对应工厂的发货顺序。
一行中的数字都以空格分隔。
输出格式：
对每个发货顺序，如果工人可以愉快完工，就在一行中输出 YES；否则输出 NO。
输入样例：
7 5 3
7 6 1 3 2 5 4
3 1 5 4 2 6 7
7 6 5 4 3 2 1
输出样例：
YES
NO
NO
题解
最近做这两个栈的题，感觉我也挺熟悉这个套路了
谁是题目最后要满足的结果，谁就放在where里面判断、
首先要来的数据先和规定要排的数据比较一下
若不同，规定要排的数据就和栈里的数据比较一下
若也不同，将 要来的数据放到栈中
如果栈满退出
Code
#include <iostream>
#include <queue>
#include <stack>
using namespace std;
int N, M, K;
bool f(queue<int> q)
{
int i = 1;
stack<int> s;
while (i < N)
{
if (!q.empty() && i == q.front())
q.pop(), i++;
else
{
if (!s.empty() && s.top() == i)
s.pop(), i++;
else
s.push(q.front()), q.pop();
if ((int)s.size() == M + 1)
return false;
}
}
return true;
}
int main()
{
cin >> N >> M >> K;
while (K--)
{
queue<int> q;
for (int i = 0; i < N; i++)
{
int x;
cin >> x;
q.push(x);
}
cout << (f(q) ? "YES\n" : "NO\n");
}
return 0;
}
L2-2 三足鼎立 (25 分)
当三个国家中的任何两国实力之和都大于第三国的时候，这三个国家互相结盟就呈“三足鼎立”之势，这种状态是最稳定的。
现已知本国的实力值，又给出 n 个其他国家的实力值。我们需要从这 n 个国家中找 2 个结盟，以成三足鼎立。有多少种选择呢？
输入格式：
输入首先在第一行给出 2 个正整数 n（2≤n≤105）和 P（≤109），分别为其他国家的个数、以及本国的实力值。随后一行给出 n 个正整数，表示n 个其他国家的实力值。每个数值不超过 109，数字间以空格分隔。
输出格式：
在一行中输出本国结盟选择的个数。
输入样例：
7 30
42 16 2 51 92 27 35
输出样例：
9
样例解释：
能联合的另外 2 个国家的 9 种选择分别为：
{16, 27}, {16, 35}, {16, 42}, {27, 35}, {27, 42}, {27, 51}, {35, 42}, {35, 51}, {42, 51}。
题解
用二分来枚举可用区间
分别枚举左端点和右端点
注意 枚举的时候 端点的情况一定要想明白
Code
#include <algorithm>
#include <iostream>
#include <cmath>
using namespace std;
const int n = 1e5 + 10;
int a[n];
int main()
{
int N, x;
cin >> N >> x;
for (int i = 0; i < N; i++)
cin >> a[i];
long long sum = 0;
sort(a, a + N);
for (int i = 0; i < N; i++)
{
// 寻找右边第一个行的元素
int l = upper_bound(a + i + 1, a + N, abs(a[i] - x)) - a;
// 寻找右边第一个不行的元素
// 用low的原因是 有可能出现正红是a[i]+x 的情况 可以过滤掉
// 其实真正可用的数是到 r-1这里
int r = lower_bound(a + i + 1, a + N, a[i] + x) - a;
sum += (r - l);
}
cout << sum << endl;
return 0;
}
L2-3 这是二叉搜索树吗？ (25 分)
一棵二叉搜索树可被递归地定义为具有下列性质的二叉树：对于任一结点，
- 其左子树中所有结点的键值小于该结点的键值；
- 其右子树中所有结点的键值大于等于该结点的键值；
- 其左右子树都是二叉搜索树。
所谓二叉搜索树的“镜像”，即将所有结点的左右子树对换位置后所得到的树。
给定一个整数键值序列，现请你编写程序，判断这是否是对一棵二叉搜索树或其镜像进行前序遍历的结果。
输入格式：
输入的第一行给出正整数 N（≤1000）。随后一行给出 N 个整数键值，其间以空格分隔。
输出格式：
如果输入序列是对一棵二叉搜索树或其镜像进行前序遍历的结果，则首先在一行中输出 YES ，然后在下一行输出该树后序遍历的结果。数字间有 1 个空格，一行的首尾不得有多余空格。若答案是否，则输出 NO。
输入样例 1：
7
8 6 5 7 10 8 11
输出样例 1：
YES
5 7 6 8 11 10 8
输入样例 2：
7
8 10 11 8 6 7 5
输出样例 2：
YES
11 8 10 7 5 6 8
输入样例 3：
7
8 6 8 5 10 9 11
输出样例 3：
NO
这次线上Code，原因是下面的题解比较长，且包含其他代码，但仍建议先看题解
Code
#include <iostream>
#include <vector>
using namespace std;
const int n = 1010;
vector<int> post;
int a[n];
int f = 0;
void trans(int root, int tail)
{
if (root > tail)
return;
int i = root + 1, j = tail;
int root_data = a[root];
if (!f)
{
while (i <= tail && a[i] < root_data)
i++;
while (j > root && root_data <= a[j])
j--;
}
else
{
while (i <= tail && a[i] >= root_data)
i++;
while (j > root && a[j] < root_data)
j--;
}
if (i - j != 1)
return;
trans(root + 1, j);
trans(i, tail);
post.push_back(root_data);
}
int main()
{
int N;
cin >> N;
for (int i = 0; i < N; i++)
cin >> a[i];
trans(0, N - 1);
if (post.size() != N)
{
post.clear();
f = 1;
trans(0, N - 1);
}
if (post.size() != N)
cout << "NO";
else
{
cout << "YES\n";
int f = 0;
for (auto &e : post)
{
if (f++ != 0)
cout << " ";
cout << e;
}
}
return 0;
}
题解
最重要的是从这个题中学到了什么，先说说这个题：
我看博客上，清一色的代码都是这样，当然我也是学了人家的这种代码，才来写博的。不过我又有点自己的理解。
根据这个前序直接得到后续，看着貌似不容易，但其实根据二叉搜索树的定义，可以想清楚。
8
6 10
5 7 8 11
可以发现，每个子树的根都是大于他的左子树的，并且小于等于他的右子树。
所以，我们可以根据这个性质，来划分~ 划分他的左子树和右子树。害，就如同快排一样，一直划分，直到不能划分为止。
所以呀，我们仅仅需要在递归函数中，求出左右子树的区间就行啦。
怎么求呢：两个循环搞定！
假设当前区间是[root, tail] 那么左子树的开始于 root+1,（因为root是根的位置）
右子树开始结束于：tail
让两个指针i,j分别 一直 往右 往左 走 即可
需要满足的条件分别是：
wherer(i <= tail && a[i] < root_data)
while (j > root && root_data <= a[j])
最后结束的时候，如果这个二叉搜索树是合法的：i正好在j的左边 即i-j=1
那么左子树区间：[root+1, j]
右子树区间：[i, tail]
上面的过程 相当于树的遍历
那么如果要得到后续，就在递归函数的末尾处，将root上的数据记录即可
由此，可以联想一下：中序可以直接求嘛？如果给出后续，直接求先序也类似嘛？
1. 尝试得到中序
#include <iostream>
#include <vector>
using namespace std;
const int n = 1010;
vector<int> post;
int a[n];
void trans(int root, int tail)
{
if (root > tail)
return;
int i = root + 1, j = tail;
int root_data = a[root];
while (i <= tail && a[i] < root_data)
i++;
while (j > root && root_data <= a[j])
j--;
if (i - j != 1)
return;
trans(root + 1, j);
post.push_back(root_data);
trans(i, tail);
}
int main()
{
int N;
cin >> N;
for (int i = 0; i < N; i++)
cin >> a[i];
trans(0, N - 1);
for (auto &e : post)
{
if (f++ != 0)
cout << " ";
cout << e;
}
return 0;
}
样例尝试：
输入
7
8 6 5 7 10 8 11
输出
5 6 7 8 8 10 11
仅仅移动了位置post的位置，就得到了中序结果。说明这个递归函数的作用就是遍历一遍树
2. 尝试后序 转 先序
刚刚手写了一下，hhh，还挺简单的，如果理解了上面的
分析一下数据：
8
6 10
5 7 8 11
后序：5 7 6 8 11 108
每个区间的根是最后一个数，所以左子树的区间就是：[head, j]
右子树区间:[i, root-1]
注意：这里的head和root的意义
上代码：
#include <iostream>
#include <vector>
using namespace std;
const int n = 1010;
vector<int> post;
int a[n];
int f = 0;
void trans(int head, int root)
{
if (head > root)
return;
int i = head, j = root - 1;
int root_data = a[root];
while (i < root && a[i] < root_data)
i++;
while (j >= head && a[j] >= root_data)
j--;
if (i - j != 1)
return;
trans(head, j);
post.push_back(root_data);
trans(i, root - 1);
}
int main()
{
int N;
cin >> N;
for (int i = 0; i < N; i++)
cin >> a[i];
trans(0, N - 1);
for (auto &e : post)
{
if (f++ != 0)
cout << " ";
cout << e;
}
return 0;
}
L2-4 网红点打卡攻略 (25 分)
一个旅游景点，如果被带火了的话，就被称为“网红点”。大家来网红点游玩，俗称“打卡”。在各个网红点打卡的快（省）乐（钱）方法称为“攻略”。你的任务就是从一大堆攻略中，找出那个能在每个网红点打卡仅一次、并且路上花费最少的攻略。
输入格式：
首先第一行给出两个正整数：网红点的个数 N（1<N≤200）和网红点之间通路的条数 M。随后 M 行，每行给出有通路的两个网红点、以及这条路上的旅行花费（为正整数），格式为“网红点1 网红点2 费用”，其中网红点从 1 到 N 编号；同时也给出你家到某些网红点的花费，格式相同，其中你家的编号固定为 0。
再下一行给出一个正整数 K，是待检验的攻略的数量。随后 K 行，每行给出一条待检攻略，格式为：
nV1 V2 ⋯ V**n
其中 n(≤200) 是攻略中的网红点数，V**i 是路径上的网红点编号。这里假设你从家里出发，从 V1 开始打卡，最后从 V**n 回家。
输出格式：
在第一行输出满足要求的攻略的个数。
在第二行中，首先输出那个能在每个网红点打卡仅一次、并且路上花费最少的攻略的序号（从 1 开始），然后输出这个攻略的总路费，其间以一个空格分隔。如果这样的攻略不唯一，则输出序号最小的那个。
题目保证至少存在一个有效攻略，并且总路费不超过 109。
输入样例：
6 13
0 5 2
6 2 2
6 0 1
3 4 2
1 5 2
2 5 1
3 1 1
4 1 2
1 6 1
6 3 2
1 2 1
4 5 3
2 0 2
7
6 5 1 4 3 6 2
6 5 2 1 6 3 4
8 6 2 1 6 3 4 5 2
3 2 1 5
6 6 1 3 4 5 2
7 6 2 1 3 4 5 2
6 5 2 1 4 3 6
输出样例：
3
5 11
样例说明：
第 2、3、4、6 条都不满足攻略的基本要求，即不能做到从家里出发，在每个网红点打卡仅一次，且能回到家里。所以满足条件的攻略有 3 条。
第 1 条攻略的总路费是：(0->5) 2 + (5->1) 2 + (1->4) 2 + (4->3) 2 + (3->6) 2 + (6->2) 2 + (2->0) 2 = 14；
第 5 条攻略的总路费同理可算得：1 + 1 + 1 + 2 + 3 + 1 + 2 = 11，是一条更省钱的攻略；
第 7 条攻略的总路费同理可算得：2 + 1 + 1 + 2 + 2 + 2 + 1 = 11，与第 5 条花费相同，但序号较大，所以不输出。
题解
需要满足的条件：
- 每个路径只能走一次
- 必须都走
- 从0开始 从0结束
- 必须是有路的
结果需要得到满足的条数和最小值
用set来保证路径只走一次且必须都走
然后判断相邻的两个点是否有路
注意：有一个点的和有可能是最大int，所以需要注意一下 3分呢
Code
#include <iostream>
#include <set>
#include <vector>
#include <cstring>
using namespace std;
const int n = 220;
int a[n][n];
int N, M;
// 判断函数
int f()
{
set<int> ret;
int K;
cin >> K;
vector<int> v;
v.push_back(0);
int t = 0;
while (K--)
{
int x;
cin >> x;
if (ret.find(x) != ret.end())
t = -1;
ret.insert(x);
v.push_back(x);
}
if (t)
return -1;
v.push_back(0);
if (int(ret.size()) != N)
return -1;
int sum = 0;
for (int i = 0; i < (int)v.size() - 1; i++)
{
if (a[v[i]][v[i + 1]] == -1)
return -1;
sum += a[v[i]][v[i + 1]];
}
return sum;
}
int main()
{
memset(a, -1, sizeof(a));
cin >> N >> M;
while (M--)
{
int x, y, d;
cin >> x >> y >> d;
a[x][y] = d;
a[y][x] = d;
}
cin >> M;
int ans, mint = 1e78;
int cnt = 0;
for (int i = 1; i <= M; i++)
{
int t = f();
if (t == -1)
continue;
cnt++;
if (mint > t)
mint = t, ans = i;
}
cout << cnt << endl;
cout << ans << ' ' << mint << endl;
return 0;
}
边栏推荐
- A 2.5D Cancer Segmentation for MRI Images Based on U-Net
- 2020-09-21 referer字符串切分 boost gateway代码组织层次
- Constructing SQL statements by sprintf() function in C language
- 单片机集成开发环境Keil5的使用
- JVM四种调用方法的指令
- 2019.11.3学习总结
- JNI. H description
- 2020-09-25 boost库的noncopyable，用于单例模式
- Pointer functions and function pointers
- 2019.11.20训练总结
猜你喜欢
Application of keil5 integrated development environment for single chip microcomputer
Flutter 基础组件之 Image
图片验证码控件
Container of the basic component of the flutter
RecyclerView 粘性（悬浮）头部
Constructing SQL statements by sprintf() function in C language
GridView of basic component of shutter
Zabbix4.4 configure the indicators of the monitoring server and solve the garbled graphics pages
使用Rancher搭建Kubernetes集群
A 3D Dual Path U-Net of Cancer Segmentation Based on MRI
随机推荐
任务调度器之Azkaban的使用
leetcode MYSQL数据库题目177
Rikka with Cake（线段树+线段树）
Codeforces Round ＃645 (Div. 2)
Wechat applet realizes store function
leetcode MYSQL数据库题目181
Leetcode MySQL database topic 178
2020-09-17 gateway业务流程 两个任务：referer认证和非商品模板化
Image of the basic component of the shutter
Install and configure redis in the Linux environment, and set the boot auto start
Wechat applet implements the data listener watch, including the watch that destroys the watch and sub attributes
指针函数和函数指针
Signal works: time varying and time invariant
2019-11-10训练总结
FreeRTOS(八)——时间管理
Codeforces Round ＃652 (Div. 2)
单片机集成开发环境Keil5的使用
Flutter 基础组件之 ListView
FreeRTOS (VIII) - time management
Listview of the basic component of the shutter