【纪中2020.4.22日】模拟赛题解

目录：

T1：潜伏者
T2：Hankson的趣味题
T3：最优贸易
T4：靶形数独

这次的题是洛谷上的题……不是USACO了

正题：

T1：潜伏者

题目描述

     R 国和S 国正陷入战火之中，双方都互派间谍，潜入对方内部，伺机行动。
     历尽艰险后，潜伏于 S 国的R 国间谍小C 终于摸清了S 国军用密码的编码规则：
     1． S 国军方内部欲发送的原信息经过加密后在网络上发送，原信息的内容与加密后所得的内容均由大写字母‘A’-‘Z’构成（无空格等其他字符）。
     2． S 国对于每个字母规定了对应的“密字”。加密的过程就是将原信息中的所有字母替换为其对应的“密字”。
     3． 每个字母只对应一个唯一的“密字”，不同的字母对应不同的“密字”。“密字”可以和原字母相同。
     例如，若规定‘A’的密字为‘A’，‘B’的密字为‘C’（其他字母及密字略），则原信息“ABA”被加密为“ACA”。
     现在，小 C 通过内线掌握了S 国网络上发送的一条加密信息及其对应的原信息。小C希望能通过这条信息，破译S 国的军用密码。小C 的破译过程是这样的：扫描原信息，对于原信息中的字母x（代表任一大写字母），找到其在加密信息中的对应大写字母y，并认为在密码里y 是x 的密字。如此进行下去直到停止于如下的某个状态：
     1． 所有信息扫描完毕，‘A’-‘Z’ 所有 26 个字母在原信息中均出现过并获得了相应的“密字”。
     2． 所有信息扫描完毕，但发现存在某个（或某些）字母在原信息中没有出现。
     3． 扫描中发现掌握的信息里有明显的自相矛盾或错误（违反S 国密码的编码规则）。例如某条信息“XYZ”被翻译为“ABA”就违反了“不同字母对应不同密字”的规则。
     在小 C 忙得头昏脑涨之际，R 国司令部又发来电报，要求他翻译另外一条从S 国刚刚截取到的加密信息。现在请你帮助小C：通过内线掌握的信息，尝试破译密码。然后利用破译的密码，翻译电报中的加密信息。

输入

输入文件名为 spy.in，共3 行，每行为一个长度在1 到100 之间的字符串。

第 1 行为小C 掌握的一条加密信息。
第 2 行为第1 行的加密信息所对应的原信息。
第 3 行为R 国司令部要求小C 翻译的加密信息。
输入数据保证所有字符串仅由大写字母‘A’-‘Z’构成，且第1 行长度与第2 行相等。

输出

输出文件 spy.out 共1 行。

若破译密码停止时出现 2，3 两种情况，请你输出“Failed”（不含引号，注意首字母大写，其它小写）。

否则请输出利用密码翻译电报中加密信息后得到的原信息。

样例输入

Sample Input1：

AA

AB

EOWIE

Sample Input2：

QWERTYUIOPLKJHGFDSAZXCVBN

ABCDEFGHIJKLMNOPQRSTUVWXY

DSLIEWO

Sample Input3：

MSRTZCJKPFLQYVAWBINXUEDGHOOILSMIJFRCOPPQCEUNYDUMPP

YIZSDWAHLNOVFUCERKJXQMGTBPPKOIYKANZWPLLVWMQJFGQYLL

FLSO

样例输出

Sample Output1：

Failed

【输入输出样例 1 说明】

原信息中的字母‘A’和‘B’对应相同的密字，输出“Failed”

Sample Output2：

Failed

【输入输出样例2 说明】

字母‘Z’在原信息中没有出现，输出“Failed”。

Sample Output3：

NOIP

分析：

先输入
再检查是否failed（重点）
（1）输入的字符串是否保证26个字母都有自己的密码
（2）判断是否一对一
最后使用三个数组，一个数组做标记，一个做比较，一个输出
要做一些字符串转换之类的

CODE：

#include
#include
char fir[101],sec[101],tr[101];
char bol[101],bol1[101];
int flag[101];
int len;
int main() 
{
	freopen("spy.in","r",stdin);
	freopen("spy.out","w",stdout);
	scanf("%s%s%s",&fir,&sec,&tr);
	memset(flag,0,sizeof(flag));
	len=strlen(fir);
	if(len<26)
	{
		printf("Failed");
		return 0;
	} 
	for(int i=0;sec[i];i++)  //判断是否出现一对多的情况
	
	{ 
		if(flag[sec[i]-'A']!=1){
			bol[sec[i]-'A']=fir[i];  //都是要字符转换
			flag[sec[i]-'A']=1;  //标记
			bol1[fir[i]-'A']=sec[i]; 
		}
		else
		{
			if(bol[sec[i]-'A']!=fir[i])
			{
				printf("Failed");
				return 0;
			}	
		}	
	}
	for(int i=0;tr[i];i++)
		printf("%c",bol1[tr[i]-'A']);  //转换字符输出
	return 0;
}

T2：Hankson的趣味题

题目描述

    Hanks 博士是BT (Bio-Tech，生物技术) 领域的知名专家，他的儿子名叫Hankson。现在，刚刚放学回家的Hankson 正在思考一个有趣的问题。
    今天在课堂上，老师讲解了如何求两个正整数c1 和c2 的最大公约数和最小公倍数。现在Hankson 认为自己已经熟练地掌握了这些知识，他开始思考一个“求公约数”和“求公倍数”之类问题的“逆问题”，这个问题是这样的：已知正整数a0,a1,b0,b1，设某未知正整数x 满足：
    1． x 和a0 的最大公约数是a1；
    2． x 和b0 的最小公倍数是b1。
    Hankson 的“逆问题”就是求出满足条件的正整数x。但稍加思索之后，他发现这样的x 并不唯一，甚至可能不存在。因此他转而开始考虑如何求解满足条件的x 的个数。请你帮助他编程求解这个问题。

输入

输入文件名为 son.in。第一行为一个正整数n，表示有n 组输入数据。接下来的n 行每行一组输入数据，为四个正整数a0，a1，b0，b1，每两个整数之间用一个空格隔开。输入数据保证a0 能被a1 整除，b1 能被b0 整除。

输出

输出文件 son.out 共n 行。每组输入数据的输出结果占一行，为一个整数。
对于每组数据：若不存在这样的 x，请输出0；
若存在这样的 x，请输出满足条件的x 的个数；

样例输入

2
41 1 96 288
95 1 37 1776

样例输出

6
2

分析：

如果gcd(a,b)=k，那么gcd(a/k,b/k)=1
然后就知道 gcd(b1/b0,b1/x)=1
且 gcd(x/a1,a0/a1)=1

CODE：

#include
#include
#include
#include
#include
using namespace std;
typedef long long LL;
LL gcd(LL x,LL y)
{
    if(y%x==0)
    {
        return x;
    }
    else
    {
        return gcd(y,x%y);  //辗转相除法
    }
}
LL lcm(LL x,LL y)
{
    return x/gcd(x,y)*y;
}
int main()
{
	freopen("son.in","r",stdin);
	freopen("son.out","w",stdout);
    LL n=0;
    scanf("%lld",&n);
    while(n--)
    {
        LL ans=0,ax=0,ay=0,bx=0,by=0;
        scanf("%lld%lld%lld%lld",&ax,&ay,&bx,&by);
        LL t=(LL)sqrt((LL)by+1);
        for(LL i=1;i<=t;i++)
        {
            if(by%i==0)
            {
                if(gcd(i,ax)==ay&&lcm(i,bx)==by)  //上面公式
                {
                    ans++;  //计数
                }
                if(i!=by/i)
                {
                    if(gcd(by/i,ax)==ay&&lcm(by/i,bx)==by)  //上面推出的
                    {
                        ans++; //计数
                    }
                }
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}

T3：最优贸易

这道题我之前在学校做过，洛谷的最短路题目……
我还写了题解…做两遍spfa，建反图……
题目传送门

题解传送门

T4：靶形数独

题目描述

     小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向Z 博士请教，Z 博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。

    靶形数独的方格同普通数独一样，在 9 格宽×9 格高的大九宫格中有9 个3 格宽×3 格高的小九宫格（用粗黑色线隔开的）。在这个大九宫格中，有一些数字是已知的，根据这些数字，利用逻辑推理，在其他的空格上填入1 到9 的数字。每个数字在每个小九宫格内不能重复出现，每个数字在每行、每列也不能重复出现。但靶形数独有一点和普通数独不同，即每一个方格都有一个分值，而且如同一个靶子一样，离中心越近则分值越高。（如图）





    上图具体的分值分布是：最里面一格（黄色区域）为 10 分，黄色区域外面的一圈（红色区域）每个格子为9 分，再外面一圈（蓝色区域）每个格子为8 分，蓝色区域外面一圈（棕色区域）每个格子为7 分，最外面一圈（白色区域）每个格子为6 分，如上图所示。比赛的要求是：每个人必须完成一个给定的数独（每个给定数独可能有不同的填法），而且要争取更高的总分数。而这个总分数即每个方格上的分值和完成这个数独时填在相应格上的数字的乘积的总和。如图，在以下的这个已经填完数字的靶形数独游戏中，总分数为2829。游戏规定，将以总分数的高低决出胜负。




    由于求胜心切，小城找到了善于编程的你，让你帮他求出，对于给定的靶形数独，能够得到的最高分数。

输入

输入文件名为 sudoku.in。
一共 9 行。每行9 个整数（每个数都在0—9 的范围内），表示一个尚未填满的数独方格，未填的空格用“0”表示。每两个数字之间用一个空格隔开。

输出

输出文件 sudoku.out 共1 行。
输出可以得到的靶形数独的最高分数。如果这个数独无解，则输出整数-1。

样例输入

Sample Input1：

7 0 0 9 0 0 0 0 1

1 0 0 0 0 5 9 0 0

0 0 0 2 0 0 0 8 0

0 0 5 0 2 0 0 0 3

0 0 0 0 0 0 6 4 8

4 1 3 0 0 0 0 0 0

0 0 7 0 0 2 0 9 0

2 0 1 0 6 0 8 0 4

0 8 0 5 0 4 0 1 2

Sample Input2：

0 0 0 7 0 2 4 5 3

9 0 0 0 0 8 0 0 0

7 4 0 0 0 5 0 1 0

1 9 5 0 8 0 0 0 0

0 7 0 0 0 0 0 2 5

0 3 0 5 7 9 1 0 8

0 0 0 6 0 1 0 0 0

0 6 0 9 0 0 0 0 1

0 0 0 0 0 0 0 0 6

样例输出

Sample Output1：

2829

Sample Output2：

2852

分析：

首先要初始化三个数组：行、列、大宫格 用于判重
之后的思路就很清晰了，直接dfs
有一点值得注意，就是大宫格的索引推导
按从上到下，从左到右的顺序
用手画一下可以推出 (x,y) 元素位于第 (x-1)/3*3+(y-1)/3+1 个大宫格上
与普通数独不同的是，靶形数独需要计算分数
我们可以简单的推出简化的计算公式
再往内部就每一层再加多一次
即：

int total = 2430+board[5][5];

然后因为数独可能有多解，因此直接深搜可能会超时，剪枝也难以进行，可以想到自己平时做数独的时候都是从给定数字多的一行或一列开始入手，即深搜要有一个优先级。

这时我们可以再初始化两个数组，一个是每行的给定数字个数，另一个是数组下标，那么我们可以通过对数组下标排序得到深搜的优先级

CODE：

#include
#include
#include 
#include
using namespace std;
int board[10][10];
int r[10][10],c[10][10],b[10][10],z[10],u[10];//行、列、大宫格判重数组 和 每行的给定数字的数组及其数组下标
int ans=-1;
bool cmp(int x,int y)//重载cmp
{
    return u[x]>u[y];
}
void cal() //简化计算公式
{
    int total=2430+board[5][5];
    for(int i=2;i<=8;i++)
    {
        for(int j=2;j<=8;j++)
        {
            if (i>=4&&i<=6&&j>=4&&j<=6) total+=board[i][j]*3;
            else if (i>=3&&i<=7&&j>=3&&j<=7) total+=board[i][j]*2;
            else total+=board[i][j];
        }
    }
    ans=max(ans,total);
}
void dfs(int x,int y)  //优先级深搜，把原来的x改成z[x]
{
    if(board[z[x]][y])
    {
        if (x==9&&y==9) cal();
        if (y==9) dfs(x+1,1);
        else dfs(x,y+1);
    }
    else
    {
        for(int i=1;i<=9;i++)
        {
            if(r[z[x]][i]==0&&c[y][i]==0&&b[(z[x]-1)/3*3+(y-1)/3+1][i]==0)
            {
                r[z[x]][i]=1;
                c[y][i]=1;
                b[(z[x]-1)/3*3+(y-1)/3+1][i]=1;
                board[z[x]][y]=i;
                if (x==9&&y==9) cal();
                if (y==9) dfs(x+1,1);
                else dfs(x,y+1);
                board[z[x]][y]=0;
                r[z[x]][i]=0;
                c[y][i]=0;
                b[(z[x]-1)/3*3+(y-1)/3+1][i]=0;
            }
        }
    }
}

int main()
{
	freopen("sudoku.in","r",stdin);
	freopen("sudoku.out","w",stdout);
    for(int i=1;i<=9;i++)
    {
        for(int j=1;j<=9;j++)
        {
            cin>>board[i][j];
            if(board[i][j])
            {
                r[i][board[i][j]]=1;
                c[j][board[i][j]]=1;
                b[(i-1)/3*3+(j-1)/3+1][board[i][j]]=1;
                u[i]++;
            }
        }
        z[i]=i;
    }
    sort(z+1,z+10,cmp);
    dfs(1,1);
    cout<<ans<<endl;
    return 0;
}