2020年团体程序设计天梯赛-总决赛【个人部分题解】

第一次打这个，我以为是团体赛，实际上就是10个人单独打，然后分数相加，一个队的也不能交流，这不就是个人赛嘛…

个人比赛结果：

团队比赛结果：

团队国一，个人国二，还行。

L1-1 嫑废话上代码 (5分)

Linux 之父 Linus Torvalds 的名言是：“Talk is cheap. Show me the code.”（嫑废话，上代码）。本题就请你直接在屏幕上输出这句话。

输入格式：
本题没有输入。

输出格式：
在一行中输出 Talk is cheap. Show me the code.。

输入样例：
无
输出样例：
Talk is cheap. Show me the code.

#include 
using namespace std;
int main()
{
    cout << "Talk is cheap. Show me the code." << endl;
    return 0;
}

L1-2 猫是液体 (5分)

测量一个人的体积是很难的，但猫就不一样了。因为猫是液体，所以可以很容易地通过测量一个长方体容器的容积来得到容器里猫的体积。本题就请你完成这个计算。

输入格式：
输入在第一行中给出 3 个不超过 100 的正整数，分别对应容器的长、宽、高。

输出格式：
在一行中输出猫的体积。

输入样例：
23 15 20
输出样例：
6900

#include 
using namespace std;
typedef long long ll;
int main()
{
    ll a,b,c;
    cin>>a>>b>>c;
    cout << a*b*c << endl;
    return 0;
}

L1-3 洛希极限 (10分)

科幻电影《流浪地球》中一个重要的情节是地球距离木星太近时，大气开始被木星吸走，而随着不断接近地木“刚体洛希极限”，地球面临被彻底撕碎的危险。但实际上，这个计算是错误的。

洛希极限（Roche limit）是一个天体自身的引力与第二个天体造成的潮汐力相等时的距离。当两个天体的距离少于洛希极限，天体就会倾向碎散，继而成为第二个天体的环。它以首位计算这个极限的人爱德华·洛希命名。（摘自百度百科）

大天体密度与小天体的密度的比值开 3 次方后，再乘以大天体的半径以及一个倍数（流体对应的倍数是 2.455，刚体对应的倍数是 1.26），就是洛希极限的值。例如木星与地球的密度比值开 3 次方是 0.622，如果假设地球是流体，那么洛希极限就是 0.622×2.455=1.52701 倍木星半径；但地球是刚体，对应的洛希极限是 0.622×1.26=0.78372 倍木星半径，这个距离比木星半径小，即只有当地球位于木星内部的时候才会被撕碎，换言之，就是地球不可能被撕碎。

本题就请你判断一个小天体会不会被一个大天体撕碎。

输入格式：
输入在一行中给出 3 个数字，依次为：大天体密度与小天体的密度的比值开 3 次方后计算出的值（≤1）、小天体的属性（0 表示流体、1 表示刚体）、两个天体的距离与大天体半径的比值（>1 但不超过 10）。

输出格式：
在一行中首先输出小天体的洛希极限与大天体半径的比值（输出小数点后2位）；随后空一格；最后输出 ^_^ 如果小天体不会被撕碎，否则输出 T_T。

输入样例 1：
0.622 0 1.4
输出样例 1：
1.53 T_T
输入样例 2：
0.622 1 1.4
输出样例 2：
0.78 ^_^

#include 
using namespace std;
typedef long long ll;
int main()
{
    ios::sync_with_stdio(false);
    double a,c,t;
    int b;
    cin>>a>>b>>c;
    if(b==0)t=a*2.455;
    else t=a*1.26;
    printf("%.2f ",t);
    if(t>=c)printf("T_T\n");
    else printf("^_^\n");
    return 0;
}

L1-4 调和平均 (10分)

N 个正数的算数平均是这些数的和除以 N，它们的调和平均是它们倒数的算数平均的倒数。本题就请你计算给定的一系列正数的调和平均值。

输入格式：
每个输入包含 1 个测试用例。每个测试用例第 1 行给出正整数 N (≤1000)；第 2 行给出 N 个正数，都在区间 [0.1,100] 内。

输出格式：
在一行中输出给定数列的调和平均值，输出小数点后2位。

输入样例：
8
10 15 12.7 0.3 4 13 1 15.6
输出样例：
1.61

（这题wa了一个点，十分迷惑）

#include 
using namespace std;
typedef long long ll;
const int N=1e3+10;
double a[N];
int main()
{
    ios::sync_with_stdio(false);
    int n;
    cin>>n;
    double sum=0;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        a[i]=1.0/a[i];
        sum+=a[i];
    }
    double ans;
    if(sum==0)ans=0;
    else ans=double(n)/sum;
    printf("%.2lf\n",ans);
    return 0;
}

L1-5 胎压监测 (15分)

小轿车中有一个系统随时监测四个车轮的胎压，如果四轮胎压不是很平衡，则可能对行车造成严重的影响。

让我们把四个车轮 —— 左前轮、右前轮、右后轮、左后轮 —— 顺次编号为 1、2、3、4。本题就请你编写一个监测程序，随时监测四轮的胎压，并给出正确的报警信息。报警规则如下：

如果所有轮胎的压力值与它们中的最大值误差在一个给定阈值内，并且都不低于系统设定的最低报警胎压，则说明情况正常，不报警；
如果存在一个轮胎的压力值与它们中的最大值误差超过了阈值，或者低于系统设定的最低报警胎压，则不仅要报警，而且要给出可能漏气的轮胎的准确位置；
如果存在两个或两个以上轮胎的压力值与它们中的最大值误差超过了阈值，或者低于系统设定的最低报警胎压，则报警要求检查所有轮胎。
输入格式：
输入在一行中给出 6 个 [0, 400] 范围内的整数，依次为 1~4 号轮胎的胎压、最低报警胎压、以及胎压差的阈值。

输出格式：
根据输入的胎压值给出对应信息：

如果不用报警，输出 Normal；
如果有一个轮胎需要报警，输出 Warning: please check #X!，其中 X 是出问题的轮胎的编号；
如果需要检查所有轮胎，输出 Warning: please check all the tires!。
输入样例 1：
242 251 231 248 230 20
输出样例 1：
Normal
输入样例 2：
242 251 232 248 230 10
输出样例 2：
Warning: please check #3!
输入样例 3：
240 251 232 248 240 10
输出样例 3：
Warning: please check all the tires!

#include 
using namespace std;
typedef long long ll;
const int N=1e3+10;
int low,d,a[6];
int main()
{
    ios::sync_with_stdio(false);
    int mx=-1;
    for(int i=1;i<=4;i++)
    {
        cin>>a[i];
        mx=max(mx,a[i]);
    }
    cin>>low>>d;
    vector<int>g;
    for(int i=1;i<=4;i++)
    {
        if(a[i]<low||mx-a[i]>d)
            g.push_back(i);
    }
    int sz=g.size();
    if(sz==0)printf("Normal\n");
    else if(sz==1)printf("Warning: please check #%d!\n",g[0]);
    else printf("Warning: please check all the tires!\n");
    return 0;
}

L1-6 吃火锅 (15分)

以上图片来自微信朋友圈：这种天气你有什么破事打电话给我基本没用。但是如果你说“吃火锅”，那就厉害了，我们的故事就开始了。

本题要求你实现一个程序，自动检查你朋友给你发来的信息里有没有 chi1 huo3 guo1。

输入格式：
输入每行给出一句不超过 80 个字符的、以回车结尾的朋友信息，信息为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。当读到某一行只有一个英文句点 . 时，输入结束，此行不算在朋友信息里。

输出格式：
首先在一行中输出朋友信息的总条数。然后对朋友的每一行信息，检查其中是否包含 chi1 huo3 guo1，并且统计这样厉害的信息有多少条。在第二行中首先输出第一次出现 chi1 huo3 guo1 的信息是第几条（从 1 开始计数），然后输出这类信息的总条数，其间以一个空格分隔。题目保证输出的所有数字不超过 100。

如果朋友从头到尾都没提 chi1 huo3 guo1 这个关键词，则在第二行输出一个表情 -_-#。

输入样例 1：
Hello!
are you there?
wantta chi1 huo3 guo1?
that’s so li hai le
our story begins from chi1 huo3 guo1 le
.
输出样例 1：
5
3 2
输入样例 2：
Hello!
are you there?
wantta qi huo3 guo1 chi1huo3guo1?
that’s so li hai le
our story begins from ci1 huo4 guo2 le
.
输出样例 2：
5
-_-#
作者
陈越
单位
浙江大学
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

（这题也wa了一个点）

#include 
using namespace std;
typedef long long ll;
const int N=1e3+10;
string s;
string a="chi1 huo3 guo1";
int main()
{
    ios::sync_with_stdio(false);
    int cnt=0;
    int len=a.length();
    bool flag=0;
    int sum=0,k;
    while(getline(cin,s))
    {
        if(s==".")break;
        cnt++;
        int n=s.length();
        if(n<len)continue;
        for(int i=0;i<n-len+1;i++)
        {
            string t=s.substr(i,len);
            if(t==a)
            {
                if(!flag)
                {
                    flag=1;
                    k=cnt;
                }
                sum++;
            }
        }
    }
    printf("%d\n",cnt);
    if(!flag)printf("-_-#\n");
    else printf("%d %d\n",k,sum);
    return 0;
}

L1-7 前世档案 (20分)

网络世界中时常会遇到这类滑稽的算命小程序，实现原理很简单，随便设计几个问题，根据玩家对每个问题的回答选择一条判断树中的路径（如下图所示），结论就是路径终点对应的那个结点。

现在我们把结论从左到右顺序编号，编号从 1 开始。这里假设回答都是简单的“是”或“否”，又假设回答“是”对应向左的路径，回答“否”对应向右的路径。给定玩家的一系列回答，请你返回其得到的结论的编号。

输入格式：
输入第一行给出两个正整数：N（≤30）为玩家做一次测试要回答的问题数量；M（≤100）为玩家人数。

随后 M 行，每行顺次给出玩家的 N 个回答。这里用 y 代表“是”，用 n 代表“否”。

输出格式：
对每个玩家，在一行中输出其对应的结论的编号。

输入样例：
3 4
yny
nyy
nyn
yyn
输出样例：
3
5
6
2

#include 
using namespace std;
typedef long long ll;
const int N=1e3+10;
char s[N];
int n,m;
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        cin>>s;
        int x=1;
        for(int i=0;s[i];i++)
        {
            if(s[i]=='y')x*=2;
            else x=x*2+1;
        }
        int t=(1<<n)-1;
        int ans=x-t;
        printf("%d\n",ans);
    }
    return 0;
}

L1-8 刮刮彩票 (20分)

“刮刮彩票”是一款网络游戏里面的一个小游戏。如图所示

每次游戏玩家会拿到一张彩票，上面会有 9 个数字，分别为数字 1 到数字 9，数字各不重复，并以 3×3 的“九宫格”形式排布在彩票上。

在游戏开始时能看见一个位置上的数字，其他位置上的数字均不可见。你可以选择三个位置的数字刮开，这样玩家就能看见四个位置上的数字了。最后玩家再从 3 横、3 竖、2 斜共 8 个方向中挑选一个方向，方向上三个数字的和可根据下列表格进行兑奖，获得对应数额的金币。

现在请你写出一个模拟程序，模拟玩家的游戏过程。

输入格式:
输入第一部分给出一张合法的彩票，即用 3 行 3 列给出 0 至 9 的数字。0 表示的是这个位置上的数字初始时就能看见了，而不是彩票上的数字为 0。

第二部给出玩家刮开的三个位置，分为三行，每行按格式 x y 给出玩家刮开的位置的行号和列号（题目中定义左上角的位置为第 1 行、第 1 列。）。数据保证玩家不会重复刮开已刮开的数字。

最后一部分给出玩家选择的方向，即一个整数： 1 至 3 表示选择横向的第一行、第二行、第三行，4 至 6 表示纵向的第一列、第二列、第三列，7、8分别表示左上到右下的主对角线和右上到左下的副对角线。

输出格式:
对于每一个刮开的操作，在一行中输出玩家能看到的数字。最后对于选择的方向，在一行中输出玩家获得的金币数量。

输入样例:
1 2 3
4 5 6
7 8 0
1 1
2 2
2 3
7
输出样例:
1
5
6
180

#include 
using namespace std;
typedef long long ll;
const int N=110;
int a[N][N];
bool vis[12];
int mp[30]={0,0,0,0,0,0,10000,36,720,360,80,252,108,72,54,180,72,180,119,36,306,1080,144,1800,3600};
int main()
{
    ios::sync_with_stdio(false);
    bool flag=0;
    int x0,y0;
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            cin>>a[i][j];
            vis[a[i][j]]=1;
            if(a[i][j]==0)
            {
                flag=1;
                x0=i;
                y0=j;
            }
        }
    }
    int k=0;
    if(flag) // 有0
    {
        for(int i=1;i<=9;i++)
        {
            if(!vis[i])
            {
                k=i;
                break;
            }
        }
        a[x0][y0]=k;
    }
    int x,y;
    for(int i=1;i<=3;i++)
    {
        cin>>x>>y;
        int ans=a[x][y];
        printf("%d\n",ans);
    }
    int opt;
    cin>>opt;
    int s=0;
    if(opt>=1&&opt<=3)
    {
        for(int i=1;i<=3;i++)
            s+=a[opt][i];
    }
    else if(opt>=4&&opt<=6)
    {
        for(int i=1;i<=3;i++)
            s+=a[i][opt-3];
    }
    else
    {
        if(opt==7)
        {
            for(int i=1;i<=3;i++)
                s+=a[i][i];
        }
        else
        {
            for(int i=1;i<=3;i++)
                s+=a[i][3-i+1];
        }
    }
    printf("%d\n",mp[s]);
    return 0;
}

L2-1 简单计算器 (25分)

本题要求你为初学数据结构的小伙伴设计一款简单的利用堆栈执行的计算器。如上图所示，计算器由两个堆栈组成，一个堆栈 S​1 ​​存放数字，另一个堆栈 S​2 存放运算符。计算器的最下方有一个等号键，每次按下这个键，计算器就执行以下操作：

• 从 S​1中弹出两个数字，顺序为 n​1和 n2；
• 从 S​2中弹出一个运算符 op；
• 执行计算 n2 op n1；
• 将得到的结果压回 S​1。

直到两个堆栈都为空时，计算结束，最后的结果将显示在屏幕上。

输入格式：
输入首先在第一行给出正整数 N（1

第二行给出 N 个绝对值不超过 100 的整数；第三行给出 N−1 个运算符 —— 这里仅考虑 +、-、*、/ 这四种运算。一行中的数字和符号都以空格分隔。

输出格式：
将输入的数字和运算符按给定顺序分别压入堆栈 S​1和 S​2
​​，将执行计算的最后结果输出。注意所有的计算都只取结果的整数部分。题目保证计算的中间和最后结果的绝对值都不超过 10^​9
​​。

如果执行除法时出现分母为零的非法操作，则在一行中输出：ERROR: X/0，其中 X 是当时的分子。然后结束程序。

输入样例 1：
5
40 5 8 3 2
/ * - +
输出样例 1：
2
输入样例 2：
5
2 5 8 4 4
* / - +
输出样例 2：
ERROR: 5/0

#include 
using namespace std;
typedef long long ll;
stack<int>s1;
stack<int>s2;
int main()
{
    ios::sync_with_stdio(false);
    int n,x;
    char c;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>x;
        s1.push(x);
    }
    for(int i=1;i<n;i++)
    {
        cin>>c;
        s2.push(c);
    }
    while(!s2.empty())
    {
        char opt=s2.top();s2.pop();
        int x1=s1.top();s1.pop();
        int x2=s1.top();s1.pop();
        int t;
        if(opt=='+')
        {
            t=x2+x1;
            s1.push(t);
        }
        else if(opt=='-')
        {
            t=x2-x1;
            s1.push(t);
        }
        else if(opt=='*')
        {
            t=x2*x1;
            s1.push(t);
        }
        else // 除
        {
            if(x1==0)
            {
                printf("ERROR: %d/0\n",x2);
                return 0;
            }
            else
            {
                t=x2/x1;
                s1.push(t);
            }
        }
    }
    int ans=s1.top();
    printf("%d\n",ans);
    return 0;
}

L2-2 口罩发放 (25分)

为了抗击来势汹汹的 COVID19 新型冠状病毒，全国各地均启动了各项措施控制疫情发展，其中一个重要的环节是口罩的发放。

某市出于给市民发放口罩的需要，推出了一款小程序让市民填写信息，方便工作的开展。小程序收集了各种信息，包括市民的姓名、身份证、身体情况、提交时间等，但因为数据量太大，需要根据一定规则进行筛选和处理，请你编写程序，按照给定规则输出口罩的寄送名单。

输入格式:
输入第一行是两个正整数 D 和 P（1≤D,P≤30），表示有 D 天的数据，市民两次获得口罩的时间至少需要间隔 P 天。

接下来 D 块数据，每块给出一天的申请信息。第 i 块数据（i=1,⋯,D）的第一行是两个整数 Ti 和 Si（1≤Ti,S​i ≤1000），表示在第 i 天有 T​i 条申请，总共有 S​i个口罩发放名额。随后 T​i 行，每行给出一条申请信息，格式如下：

姓名 身份证号 身体情况 提交时间

给定数据约束如下：
姓名 是一个长度不超过 10 的不包含空格的非空字符串；
身份证号 是一个长度不超过 20 的非空字符串；
身体情况 是 0 或者 1，0 表示自觉良好，1 表示有相关症状；
提交时间 是 hh:mm，为24小时时间（由 00:00 到 23:59。例如 09:08。）。注意，给定的记录的提交时间不一定有序；
身份证号 各不相同，同一个身份证号被认为是同一个人，数据保证同一个身份证号姓名是相同的。

能发放口罩的记录要求如下：
身份证号 必须是 18 位的数字（可以包含前导0）；
同一个身份证号若在第 i 天申请成功，则接下来的 P 天不能再次申请。也就是说，若第 i 天申请成功，则等到第 i+P+1 天才能再次申请；
在上面两条都符合的情况下，按照提交时间的先后顺序发放，直至全部记录处理完毕或 S​i 个名额用完。如果提交时间相同，则按照在列表中出现的先后顺序决定。
输出格式:
对于每一天的申请记录，每行输出一位得到口罩的人的姓名及身份证号，用一个空格隔开。顺序按照发放顺序确定。

在输出完发放记录后，你还需要输出有合法记录的、身体状况为 1 的申请人的姓名及身份证号，用空格隔开。顺序按照申请记录中出现的顺序确定，同一个人只需要输出一次。

输入样例:
4 2
5 3
A 123456789012345670 1 13:58
B 123456789012345671 0 13:58
C 12345678901234567 0 13:22
D 123456789012345672 0 03:24
C 123456789012345673 0 13:59
4 3
A 123456789012345670 1 13:58
E 123456789012345674 0 13:59
C 123456789012345673 0 13:59
F F 0 14:00
1 3
E 123456789012345674 1 13:58
1 1
A 123456789012345670 0 14:11
输出样例:
D 123456789012345672
A 123456789012345670
B 123456789012345671
E 123456789012345674
C 123456789012345673
A 123456789012345670
A 123456789012345670
E 123456789012345674
样例解释：
输出中，第一行到第三行是第一天的部分；第四、五行是第二天的部分；第三天没有符合要求的市民；第六行是第四天的部分。最后两行按照出现顺序输出了可能存在身体不适的人员。

（这题wa了两个点）

#include 
using namespace std;
typedef long long ll;
const int N=1e3+10;
int n,m; // n天 至少间隔m天
struct node
{
    string name;
    string id; // 检验其合法性
    int tag; // 0 or 1
    int time; // 12:00 -> 12*60+0
    int order; // 当天申请的顺序
}p[N];
struct node1
{
    string name,id;
};
vector<node>g;
map<string,int>vis; // id上次拿到口罩的day
map<string,bool>f;
bool check(string s) // 检验id是否合法
{
    int len=s.length();
    if(len!=18)return 0;
    for(int i=0;i<len;i++)
    {
        if(s[i]<'0'||s[i]>'9')return 0;
    }
    return 1;
}
bool cmp(node s1,node s2)
{
    if(s1.time!=s2.time)return s1.time<s2.time;
    return s1.order<s2.order;
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    vis.clear();
    g.clear();
    f.clear();
    for(int day=1;day<=n;day++)
    {
        int p1,p2;
        cin>>p1>>p2; // p1条记录，p2个人能拿到口罩
        int h,fen;
        char c;
        string name,id;
        int tag;
        int cnt=0;
        for(int i=1;i<=p1;i++)
        {
            cin>>name>>id>>tag>>h>>c>>fen;
            if(!check(id))continue; // 去除非法记录
            int time=h*60+fen;
            p[++cnt].name=name;
            p[cnt].id=id;
            p[cnt].tag=tag;
            p[cnt].time=time;
            p[cnt].order=cnt;
            if(tag==1)
            {
                if(!f[id])
                {
                    g.push_back({name,id});
                    f[id]=1;
                }
            }
        }
        sort(p+1,p+cnt+1,cmp);
        int tot=0;
        for(int i=1;i<=cnt;i++)
        {
            id=p[i].id;
            name=p[i].name;
            if(!vis[id]) // 这个人还没申请过
            {
                printf("%s %s\n",p[i].name.c_str(),p[i].id.c_str());
                vis[id]=day;
                tot++;
            }
            else
            {
                int last=vis[id];
                if(day-last<=m)continue; // m天之内申请过
                printf("%s %s\n",p[i].name.c_str(),p[i].id.c_str());
                vis[id]=day;
                tot++;
            }
            if(tot==p2)break;
        }
    }
    int sz=g.size();
    for(int i=0;i<sz;i++)
        printf("%s %s\n",g[i].name.c_str(),g[i].id.c_str());
    return 0;
}

L2-3 完全二叉树的层序遍历 (25分)

一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是完美二叉树。对于深度为 D 的，有 N 个结点的二叉树，若其结点对应于相同深度完美二叉树的层序遍历的前 N 个结点，这样的树就是完全二叉树。

给定一棵完全二叉树的后序遍历，请你给出这棵树的层序遍历结果。

输入格式：
输入在第一行中给出正整数 N（≤30），即树中结点个数。第二行给出后序遍历序列，为 N 个不超过 100 的正整数。同一行中所有数字都以空格分隔。

输出格式：
在一行中输出该树的层序遍历序列。所有数字都以 1 个空格分隔，行首尾不得有多余空格。

输入样例：
8
91 71 2 34 10 15 55 18
输出样例：
18 34 55 71 2 10 15 91

#include 
using namespace std;
typedef long long ll;
const int N=1e3+10;
int tree[N],a[N];
int n,cnt=0;
void dfs(int u)
{
    if(u>n)return;
    int lson=2*u;
    int rson=2*u+1;
    dfs(lson);
    dfs(rson);
    tree[u]=a[++cnt];
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    dfs(1);
    for(int i=1;i<=n;i++)
        i==n?printf("%d\n",tree[i]):printf("%d ",tree[i]);
    return 0;
}

L2-4 网红点打卡攻略 (25分)

一个旅游景点，如果被带火了的话，就被称为“网红点”。大家来网红点游玩，俗称“打卡”。在各个网红点打卡的快（省）乐（钱）方法称为“攻略”。你的任务就是从一大堆攻略中，找出那个能在每个网红点打卡仅一次、并且路上花费最少的攻略。

输入格式：
首先第一行给出两个正整数：网红点的个数 N（1

再下一行给出一个正整数 K，是待检验的攻略的数量。随后 K 行，每行给出一条待检攻略，格式为：n V1 V2 … Vn

其中 n(≤200) 是攻略中的网红点数，Vi 是路径上的网红点编号。这里假设你从家里出发，从 V1 开始打卡，最后从 Vn 回家。

输出格式：
在第一行输出满足要求的攻略的个数。

在第二行中，首先输出那个能在每个网红点打卡仅一次、并且路上花费最少的攻略的序号（从 1 开始），然后输出这个攻略的总路费，其间以一个空格分隔。如果这样的攻略不唯一，则输出序号最小的那个。

题目保证至少存在一个有效攻略，并且总路费不超过 10^9​​ 。

输入样例：
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 条花费相同，但序号较大，所以不输出。

#include 
using namespace std;
typedef long long ll;
const int N=1010;
int n,m,num,a[N],g[N][N];
bool vis[N];
int check()
{
    a[0]=0;
    a[num+1]=0;
    int s=0;
    memset(vis,0,sizeof(vis));
    int tot=0;
    for(int i=0;i<=num;i++)
    {
        int t1=a[i];
        int t2=a[i+1];
        if(!g[t1][t2]&&!g[t2][t1])return 0; // 走不到
        if(vis[t2])return 0; // 重复
        vis[t2]=1;
        s+=g[t1][t2];
        tot++;
    }
    if(tot-1<n)return 0;
    return s;
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    memset(g,0,sizeof(g));
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        g[x][y]=z;
        g[y][x]=z;
    }
    int q;
    cin>>q;
    int cnt=0;
    int mi=2e9;
    int k;
    for(int p=1;p<=q;p++)
    {
        cin>>num;
        for(int i=1;i<=num;i++)
            cin>>a[i];
        int tmp=check();
        if(tmp==0)continue;
        cnt++;
        if(tmp<mi)
        {
            mi=tmp;
            k=p;
        }
    }
    printf("%d\n",cnt);
    printf("%d %d\n",k,mi);
    return 0;
}

L3-1 那就别担心了 (30分)

下图转自“英式没品笑话百科”的新浪微博 —— 所以无论有没有遇到难题，其实都不用担心。

博主将这种逻辑推演称为“逻辑自洽”，即从某个命题出发的所有推理路径都会将结论引导到同一个最终命题（开玩笑的，千万别以为这是真正的逻辑自洽的定义……）。现给定一个更为复杂的逻辑推理图，本题就请你检查从一个给定命题到另一个命题的推理是否是“逻辑自洽”的，以及存在多少种不同的推理路径。例如上图，从“你遇到难题了吗？”到“那就别担心了”就是一种“逻辑自洽”的推理，一共有 3 条不同的推理路径。

输入格式：
输入首先在一行中给出两个正整数 N（1

接下来 M 行，每行给出一对命题之间的推理关系，即两个命题的编号 S1 S2，表示可以从 S1 推出 S2。题目保证任意两命题之间只存在最多一种推理关系，且任一命题不能循环自证（即从该命题出发推出该命题自己）。

最后一行给出待检验的两个命题的编号 A B。

输出格式：
在一行中首先输出从 A 到 B 有多少种不同的推理路径，然后输出 Yes 如果推理是“逻辑自洽”的，或 No 如果不是。

题目保证输出数据不超过 10^9。

输入样例 1：
7 8
7 6
7 4
6 5
4 1
5 2
5 3
2 1
3 1
7 1
输出样例 1：
3 Yes
输入样例 2：
7 8
7 6
7 4
6 5
4 1
5 2
5 3
6 1
3 1
7 1
输出样例 2：
3 No

（这题最后一个点超时）

#include 
using namespace std;
typedef long long ll;
const int N=510;
int n,m,s,t;
int ans=0;
bool flag=0;
bool vis[N];
vector<int>g[N];
void dfs(int u)
{
    if(u==t)
    {
        ans++;
        return;
    }
    int sz=g[u].size();
    if(sz==0)
    {
        if(u!=t)flag=1;
        return;
    }
    for(int i=0;i<sz;i++)
    {
        int v=g[u][i];
        dfs(v);
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    int x,y;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y;
        g[x].push_back(y);
    }
    cin>>s>>t;
    dfs(s);
    printf("%d ",ans);
    if(flag)printf("No\n");
    else printf("Yes\n");
    return 0;
}

L3-2 传送门 (30分)

输入样例：
5 4
+ 1 3 1
+ 1 4 3
+ 2 5 2
- 1 4 3
输出样例：
51
48
39
42
样例解释：
修改 | f(1) | f(2) | f(3) | f(4) | f(5) | 结果 — | — + 1 3 1 | 3 | 2 | 1 | 4 | 5 | 51 + 1 4 3 | 3 | 2 | 4 | 1 | 5 | 48 + 2 5 2 | 3 | 5 | 4 | 1 | 2 | 39 - 1 4 3 | 3 | 5 | 1 | 4 | 2 | 42

L3-3 可怜的复杂度 (30分)

输入样例：
4
3 2
1 1 1
3 2
1 2 1
5 2
1 2 1 2 1
10 2
80582987 187267045 80582987 187267045 80582987 187267045 80582987 187267045 80582987 187267045
输出样例：
36
44
404
44616