这学期web开发的大作业我做了一个学校管理系统，一开始是想做成教务管理系统那种，自己真正写了才发现工程过于浩大，一个人短期内很难完成啊。又一想，先做了比较基础的交作业吧，wtnl

从5月23号就开始构思了，每天都沉浸在代码的海洋里，每到傍晚都会看的脑壳痛，然后去小花坛跑跑步，然后就感觉很舒服了，回来接着写呜呜。之前几次C、C++大作业都没有想到记录下来，也可能这次自己想到了要记下来就记录下来了，不过还是手写了一点，可能还是更喜欢在纸上乱画吧hhh，虽然好久没写字了，写的字巨丑，看不下去了，就糊糊的贴出来吧。

前几天乱写了一通，然后偶然间在网上看到了Bootstrap框架，然后感觉可以用上，但是感觉有点死板，不好看，但是作为学校的管理系统，还行吧。。。

系统有三种角色，学生、教师和管理员，一开始写了学生的部分，比较简单，后来加上教师、管理员的功能越来越多，文件也越来越多，权限越来越大，不过也还好，文件命名比较容易区分，也可以画个流程图来表示一下，我觉得比较方便，推荐processon.com网站。

后来因为想实现不刷新页面，然后执行查询，直接显示结果在当前26号看了一天的Ajax框架，太头疼了，本身就有点烦不想学了，划水就过了一天，27号早上偶然间发现其实Ajax有两种实现方式，一种原生JS，一种就是jQuery，我之前一直就是看jQuery，然而不好学（短期内），但是JS方法比较简单啊，干嘛一直傻傻的非要用jQuery来实现呢，虽然JS方法视频里都说以后工作中不常用。然后bug就过了。最后就是修改样式了，修改样式调来调去真的麻烦。。。

6月2号上午，终于答辩完了，虽然我忽视了实现多条件查询，可能是因为我实现了模糊查询，而且也觉得多条件查询没什么意义，就没做这部分了。。。凉凉，被老师问到了，但是其他问题都比较简单，就过了，回来加上多条件查询，最后下午交上报告，结束啦。代码截图报告总共113页，服了。这次的web开发算起来持续了一周才写完，wtcl

可以说，这一次我从头到尾都自己构思，自己解决的bug，而且很诚心想做出一个系统来，虽然功能不全，很low，TAT。。。但是自己用心做了，就挺有成就感的，老师问也不会担心了【理直气壮】。后续有时间再完善功能吧。。。

虽然不太想做开发，但是每次修改一个功能的代码，然后去运行，测试，感觉还有点期待，成功了就会很开心，这种感觉还挺好的。不过整体坐在桌边敲代码，真的敲得腰酸背痛，脖子后面巨难受，而且有天还熬到了很晚（2点呜呜），想实现功能真的不困，就是坐着脖子难受，第二天照样6点起，继续。不过持续好几天就不行了【捂脸】，太伤身体了。。。还有我的手有一天都感觉有点鼠标手的迹象了，害。。。

啊啊啊，还有别的一堆大作业要做，溜了溜了~

setoolkit，即社会工程学工具集Social-Engineer Toolkit，该工具可用来产生钓鱼网站，在kali上可直接使用，github上也有，下载链接 https://github.com/trustedsec/social-engineer-toolkit/set/。下面就是本次学习的记录了。

首先打开kali终端，输入setoolkit，就会出现下面


选项菜单：

1
2
3
4
5
6
7

1、社会工程学攻击
2、快速追踪测试
3、第三方模块
4、升级软件
5、升级配置
6、帮助
99、退出

选1

又是选项，

1
2
3
4
5
6
7
8
9
10
11

1、鱼叉式网络钓鱼攻击
2、网页攻击
3、传染媒介式（俗称木马）
4、建立payloaad和listener
5、邮件群发攻击（夹杂木马啊payload的玩意发给你）
6、Arduino基础攻击
7、无线接入点攻击
8、二维码攻击（我喜欢）
9、Powershell攻击
10、第三反模块
99、返回上级

选2

1
2
3
4
5
6
7
8

1、java applet攻击（网页弹窗那种）
2、Metasploit 浏览器漏洞攻击
3、钓鱼网站攻击
4、标签钓鱼攻击
5、网站jacking攻击（这个真心不明白，好像也和java的攻击方式有些相同）
6、多种网站攻击方式
7、全屏幕攻击（不明所以的玩意，只能够对谷歌邮箱和脸书用）
99、返回上级

很明显，选3

之后可以选择设置1、网站模版，2、设置克隆网站，3、自己设计的网站

选择2.克隆网站，输入本机ip，就是[ ]里面的（也可以不输），回车，然后输入要克隆的网站url。
我们需要去找一个登录网站，

随便找了一个https://passport.ustc.edu.cn/login?service=https%3A%2F%2Fjw.ustc.edu.cn%2Fucas-sso%2Flogin，回车可以发现网站正在克隆，直到出现下面的就是克隆成功了。

浏览器中输入kali的ip就可以访问了。

可以说和原来的几乎一样了，当然仔细看还是有差别的。一些CSS样式没有克隆下来。下面是原网站：

在钓鱼网站中输入账号和密码，提交之后在控制台就可以看到输入的信息了，网站也会返回到原来被克隆的网站，不易被人发现。

还有选择网站模板的方法可参考https://www.freebuf.com/sectool/73409.html

注意事项：

1、使用网站克隆的方式原理：setooltie将网页下载，然后用自己的服务器来进行显示。所以要
占用80端口。PS：用阿里云主机的时候一开始没有将80端口的其他程序关闭，导致端口被占
用，钓鱼网页起不来。
2、实际应用的时候，最好布置在公网上，还有将IP和域名绑定。

PS：千万不要触犯法律哦！

问题描述
　　Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。
　　给出一列数{pi}={p0, p1, …, pn-1}，用这列数构造Huffman树的过程如下：
　　1. 找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
　　2. 重复步骤1，直到{pi}中只剩下一个数。
　　在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。
　　本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。

例如，对于数列{pi}={5, 3, 8, 2, 9}，Huffman树的构造过程如下：
　　1. 找到{5, 3, 8, 2, 9}中最小的两个数，分别是2和3，从{pi}中删除它们并将和5加入，得到{5, 8, 9, 5}，费用为5。
　　2. 找到{5, 8, 9, 5}中最小的两个数，分别是5和5，从{pi}中删除它们并将和10加入，得到{8, 9, 10}，费用为10。
　　3. 找到{8, 9, 10}中最小的两个数，分别是8和9，从{pi}中删除它们并将和17加入，得到{10, 17}，费用为17。
　　4. 找到{10, 17}中最小的两个数，分别是10和17，从{pi}中删除它们并将和27加入，得到{27}，费用为27。
　　5. 现在，数列中只剩下一个数27，构造过程结束，总费用为5+10+17+27=59。 输入格式 　　输入的第一行包含一个正整数n（n<=100）。 　　接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。
输出格式 　　输出用这些数构造Huffman树的总费用。 样例输入 5 5 3 8 2 9 样例输出 59

思路：
先将数组升序排序，a[0] 和 a[1]就是当前两个最小的数，然后a[0]+a[1]赋值给a[0]，a[1]赋值为-1，总费用sum加上a[0] ，下一次排序后将这个数删除，依次循环，直到集合中元素只剩一个。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <iostream>
#include <algorithm>
using namespace std; 
#define maxx 100
int main(){
int a[maxx];
int i,n;
cin>>n;
for(i=0;i<n;i++)
cin>>a[i];
sort(a,a+n);//从大到小排序 
int sum=0;
while(n>1){
i=0;
a[i]=a[i]+a[i+1];
sum+=a[i];
a[i+1]=-1;//将这个数除去
sort(a,a+n);
for(i=0;i<n-1;i++)
a[i]=a[i+1];
n--; 
}
cout<<sum<<endl;
return 0;
}

问题描述
　　给定一个N阶矩阵A，输出A的M次幂（M是非负整数）
　　例如：
　　A =
　　1 2
　　3 4
　　A的2次幂
　　7 10
　　15 22
输入格式
　　第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数
　　接下来N行，每行N个绝对值不超过10的非负整数，描述矩阵A的值
输出格式
　　输出共N行，每行N个整数，表示A的M次幂所对应的矩阵。相邻的数之间用一个空格隔开
样例输入
2 2
1 2
3 4
样例输出
7 10
15 22

–这个题其实不难，就是一开始我忘了矩阵乘法的相关知识Orz(⊙﹏⊙)

要注意分类讨论，矩阵的0次幂是单位矩阵，1次幂是矩阵本身，2+次幂就要借用另外两个数组来计算了。

AC代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#include <stdio.h>
int a[35][35];
int b[35][35];
int t[35][35];

int main(){
int n,m,i,j,k;
scanf("%d%d",&n,&m);
for(i=0;i<n;i++){
for(j=0;j<n;j++){
scanf("%d",&a[i][j]);
b[i][j]=a[i][j];
}
}
if(m==0){//矩阵的0次幂为单位矩阵 
for(i=0;i<n;i++){ 
for(j=0;j<n;j++){
if(i==j)
printf("1 ");
else
printf("0 ");
}
printf("\n");
}
return 0;//要结束程序 
}
if(m==1){//矩阵的1次幂为它本身 
for(i=0;i<n;i++){
for(j=0;j<n;j++)
printf("%d ",a[i][j]);
printf("\n");
}
return 0;//要结束程序 
}

while(m>=2){//矩阵2次幂及以上需要做运算 
for(i=0;i<n;i++) 
for(j=0;j<n;j++){
int k=n;
while(k){
t[i][j]+=b[i][k-1]*a[k-1][j];//t[i][j]作为中间数组 
k--;
}
} 
for(i=0;i<n;i++)
for(j=0;j<n;j++){
b[i][j]=t[i][j];//将中间计算得到的数组再赋给b[][]，便于下一次乘法 
t[i][j]=0;
}
m--;
}
for(i=0;i<n;i++){
for(j=0;j<n;j++){
printf("%d ",b[i][j]);
}
printf("\n");
} 
return 0;
}

一定要注意当m=0和m=1时，要注意结束程序，不然会出错。
例如，输入10 0：

首先，需要安装一个远程登陆软件Xshell，可以去官网下载，也可以找免费的版本。

华为的云服务器的端口是默认全部打开的，区别于阿里云，阿里云的端口需要自己去打开，两者各有利弊。在华为云控制台修改好密码就可以使用Xshell远程连接使用了。

打开Xshell，文件->新建->填写名称（容易辨别就行）和主机（云服务器的公网IP），其余内容可不变。

然后双击左边建好的会话名称，就会出现输入用户名（root）和密码（刚刚重置过的），SSH远程登陆云服务器。

如果出现SSH服务器拒绝了密码，就需要改sshd_config。

1.点击远程登录，使用屏幕上提示的用户名和密码登录，我的用户名为root，密码就是之前重置的。

2.输入sudo vi /etc/ssh/sshd_config，然后按a键或者Insert键，找到内容为PasswordAuthentication由no改为yes，改好后按ESC键，再输入:wq保存退出。

3.输入sudo service sshd reload或sudo service sshd restart重启sshd

左上角小点点由红色代表绿色就说明连接上了，界面里面也会出现一些相关提示语最后登陆时间什么时候啥的，这说明你已经远程连接成功了。登录成功页面如下：

之后就可以安装一个网站服务器了，可以选择Nginx和Apache，这里选择Apache。
（PS：肯定有很多小伙伴会看到有些这里是用Tomcat部署Java Web项目，我看到时也比较困惑。简单来说，Apache是Web应用服务器，适合静态HTML、图片等，但可以通过扩展脚本、模块等支持动态页面等，如果要使用Java的话，你需要Tomcat在Apache后台支撑，将Java请求由Apache转发给Tomcat处理。；Tomcat是应用（Java）服务器，它只是一个Servlet(JSP也翻译成Servlet)容器，可以认为是Apache的扩展，但是可以独立于Apache运行。具体二者的区别可见https://www.php.cn/apache/427666.html）

下面是安装Java jdk和Tomcat流程：

1. 获取jdk，地址：https://pan.baidu.com/s/1OJyKcbFq8nM6zizvvG1EkA 提取码：1tq5

2. 点击Xshell上的新建文件传输（如图），
   
   如果你还没安装Xftp，它会提示你去官网安装，官网可以使用电子邮箱下载免费版本，然后根据它的提示一步一步来就好了。已安装好的请自行跳过。
   
   或者你嫌麻烦，也可以用这个Xshell4：链接: https://pan.baidu.com/s/1wf1qg28PP8V5D1GRAbaqOQ 提取码: jfbq
   （1）打开软件之后新建；
   （2）主机写linux的公网IP，协议选择SFTP，端口号为22；
   （3）用户名和密码为Linux的账户(root)和密码；
   
   （4）填写完成之后点击确定，双击创建好的会话，连接到云服务器。软件里即显示本机的文件与Linux的文件，双击文件即可传递，非常方便。
   

3. 上传jdk文件到linux服务器上，自己在usr下新建文件夹/usr/software，拖动压缩包文件上传

4. 解压jdk压缩包：先用cd命令到达自己上一步创建的文件夹地址：cd /usr/software，再使用解压jdk压缩包命令：tar -xvf jdk-8u65-linux-x64.tar.gz（输入jdk后面可按tab键自动补全）。使用mv jdk1.8.0_161 jdk1.8命令，将jdk1.8.0_161重命名为jdk1.8(方便以后管理和使用)

5. 解压完成后更改环境变量。输入命令vi /etc/profile，按i进入编辑模式，光标移到末尾添加以下文本：export JAVA_HOME=/usr/software/jdk1.8 export JRE_HOME=/usr/software/jdk1.8/jre export PATH=$PATH:/usr/software/jdk1.8/bin export CLASSPATH=./:/usr/software/jdk1.8/lib:/usr/software/jdk1.8/jre/lib，如不同，记得更改文件夹名与jdk名。完成后按esc，输入:wq保存并退出。

6. 重启服务器。

7. 输入java -version出现以下英文证明安装成功。
   

8. 进入Tomcat官网下载tomcat安装包，这里下载的是9.0.31版本的。
   

9. 将tomcat压缩包通过Xftp上传到服务器/usr/software，后续操作就和上面的jdk类似了。

10. 解压tomcat压缩包：cd /usr/software再使用解压缩包命令：tar -xvf apache-tomcat-9.0.31.tar （输入apache后面可按tab键自动补全）

11. 解压完成后更改环境变量。输入命令vi /etc/profile，按i进入编辑模式，光标移到末尾添加以下文本（如有不同，记得改文件夹名称）：export CATALINA_HOME=/usr/software/apache-tomcat-9.0.31。完成后按esc，输入:wq保存并退出。

12. 进入云服务器的控制台，进入安全组规则中，添加安全组规则，配置8080端口。
    

13. 启动tomcat服务器。使用命令cd /usr/software/apache-tomcat-9.0.31/bin先进入tomcat文件夹的bin目录下，输入./startup.sh启动tomcat，成功页面如下：
    

14. 接下来在浏览器输入自己的公网ip地址(没有改端口号的话，就在ip地址后加上:8080)，出现 tomcat 的主页，则证明tomcat配置启动成功
    

Tomcat的目录结构：

Tomcat重启关闭：
1、Tomcat关闭命令./shutdown.sh
2、查看Tomcat是否以关闭ps -ef|grep java
3、如果显示以下相似信息，说明Tomcat还没有关闭

4、如果你想直接直接杀死Tomcat进程（进程号： 7010），可以使用kill命令 kill -9 7010
5、然后ps -ef|grep java继续查看Tomcat是否关闭，

如果出现以下信息，则表示Tomcat已经关闭

6、最后，启动Tomcat，命令为./startup.sh

如果要部署自己的网页项目，将项目文件夹上传到 Tomcat文件夹下的 Webapps 文件夹里就行。上传好了后，浏览器访问即可。例如：http://云服务器公网ip地址:8080/index/one.html等。（Tomcat关闭之后输入IP地址等就不能访问你的项目了）

注意，有个比较坑的地方，修改了server.xml文件的端口后，需要重启服务器，然后再运行程序。
如果你修改了对应项目的服务器的配置，那么请用你修改的端口号，而不是server.xml文件里的默认端口号。

问题描述
　　FJ在沙盘上写了这样一些字符串：
　　A1 = “A”
　　A2 = “ABA”
　　A3 = “ABACABA”
　　A4 = “ABACABADABACABA”
　　… …
　　你能找出其中的规律并写所有的数列AN吗？
输入格式
　　仅有一个数：N ≤ 26。
输出格式
　　请输出相应的字符串AN，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
样例输入
3
样例输出
ABACABA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <stdio.h>
void FJ(int n){//递归
if(n==0)
printf("%c",'A');
else{
FJ(n-1);
printf("%c",n+'A');//ASCII美国信息交换标准代码表述字母
FJ(n-1);
}
}
int main(){
int n;
scanf("%d",&n);
FJ(n-1);
printf("\n");
return 0;
}

问题描述
　　回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
　　交换的定义是：交换两个相邻的字符
　　例如mamad
　　第一次交换 ad : mamda
　　第二次交换 md : madma
　　第三次交换 ma : madam (回文！完美！)
输入格式
　　第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)
　　第二行是一个字符串，长度为N.只包含小写字母
输出格式
　　如果可能，输出最少的交换次数。
　　否则输出Impossible
样例输入
5
mamad
样例输出
3

思路：
贪心法，从左边起依次扫描，每记录一个字母，就寻找从右边起最近的与它相同的字母，移动到回文的位置，记录步数，如果最近的与它相同的字母是它本身，说明它在字串里单独存在，可以根据单独存在的字母的个数以及字串的长度来判断impossible的情况，如果排除impossible的情况，则记录它到字串中间的步数，并不需要移动它。
其中有两个注意点：

1. impossible的情况：如果有一个字符出现的次数是奇数次数，而且n是偶数，那么不可能构成回文；如果n是奇数，但是已经有一个字符出现的次数是奇数次数了，那么如果又有一个字符是奇数次数，就不可能构成回文。
2. 如果n是奇数，计算中间那个字符交换的次数的时候，不需要模拟把这个数移动到中间去，先把所有的回文数移动到位，再移动中间的奇数。因为，假设有一对数都在左边或者都在右边，那么交换成回文的时候就要经过中间，就会每次把cnt多加了1，而这个1是没有必要的，因为可以所有的回文移动完了之后再把这个独立的奇数移动过去，才能保证交换次数最少。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <iostream>
using namespace std;

int main(){
int n;
cin>>n;
string s;
cin>>s;
int j=n-1;
int cnt=0;//cnt用来统计交换的次数
int flag=0;//flag判断是否已经有一个单独的奇个数的字符了
for(int i=0;i<j;i++){
for(int k=j;k>=i;k--){
if(k==i){
if(n%2==0 || flag==1){
cout<<"Impossible";
return 0;
}
flag=1;
cnt+=n/2-i;
}
else if(s[k]==s[i]){
for(int l=k;l<j;l++){
swap(s[l],s[l+1]);//把s[k]换到s[j]处
cnt++;//统计交换次数 
}
j--;
break; 
}
}
} 
cout<<cnt;
return 0;
}

问题描述
　　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。
　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。
　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法：
　　十二亿三千四百五十六万七千零九
　　用汉语拼音表示为
　　shi er yi san qian si bai wu shi liu wan qi qian ling jiu
　　这样他只需要照着念就可以了。
　　你的任务是帮他设计这样一个系统：给定一个阿拉伯数字串，你帮他按照中文读写的规范转为汉语拼音字串，相邻的两个音节用一个空格符格开。
　　注意必须严格按照规范，比如说“10010”读作“yi wan ling yi shi”而不是“yi wan ling shi”，“100000”读作“shi wan”而不是“yi shi wan”，“2000”读作“er qian”而不是“liang qian”。
输入格式
　　有一个数字串，数值大小不超过2,000,000,000。
输出格式
　　是一个由小写英文字母，逗号和空格组成的字符串，表示该数的英文读法。
样例输入
1234567009
样例输出
shi er yi san qian si bai wu shi liu wan qi qian ling jiu

思路：

1. 首先用一个数组来存放0-9，另一个数组存放单位，单位要注意万以上的单位都只要前一个数字单位了，十万用“十”，百万用“百”等。
2. 然后考虑几种特殊情况，当0的下一位不是0才会输出ling；
3. 因为大多数情况都是数字+单位输出的，但是当数字是1，而单位是十、十万、十亿的时候只输出shi，而不是yi shi
4. 其余的就数字+单位输出了。

AC代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <iostream>
using namespace std;
#include <cstring>

int main(){
string s;
cin>>s;
int n=s.length();

string nums[10]={"ling","yi","er","san","si","wu","liu","qi","ba","jiu"};//每一位上的数字 
string units[11]={"","","shi","bai","qian","wan","shi","bai","qian","yi","shi"};//单位 

for(int i=0;i<n;i++){
int num=s[i]-'0';//字符转换成数字 
if(num==0){
//这里要注意C++ string的长度陷阱 
if(i+1<n && s[i+1]!='0')//下一个不是0才输出ling 
cout<<nums[num]<<" ";
}
else if((n-i==2 || n-i==6 || n-i==10) && num==1){
//十、十万、十亿位上有1的时候输出shi，而不是yi shi 
cout<<units[n-i]<<" ";
}
else{
cout<<nums[num]<<" "<<units[n-i]<<" ";
}
}
return 0;
}

总的来说，这题还是比较坑的orz

参考自https://blog.csdn.net/qq_40691051/article/details/105001465

问题描述
　　话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先t米或以上，它们就会停下来休息s秒。对于不同的兔子，t，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。
　　然而有些比赛相当漫长，全程观看会耗费大量时间，而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1（表示每秒兔子能跑v1米），乌龟的速度v2，以及兔子对应的t，s值，以及赛道的长度l——就能预测出比赛的结果。但是小华很懒，不想通过手工计算推测出比赛的结果，于是他找到了你——清华大学计算机系的高才生——请求帮助，请你写一个程序，对于输入的一场比赛的数据v1，v2，t，s，l，预测该场比赛的结果。
输入格式
　　输入只有一行，包含用空格隔开的五个正整数v1，v2，t，s，l，其中(v1,v2<=100;t<=300;s<=10;l<=10000且为v1,v2的公倍数)
输出格式
　　输出包含两行，第一行输出比赛结果——一个大写字母“T”或“R”或“D”，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点。
　　第二行输出一个正整数，表示获胜者（或者双方同时）到达终点所耗费的时间（秒数）。
样例输入
10 5 5 2 20
样例输出
D
4
样例输入
10 5 5 1 20
样例输出
R
3
样例输入
10 5 5 3 20
样例输出
T
4

思路：
用两个数组分别存放兔子和乌龟跑的路程，数组下标正好对应跑的时间，再用一个flag标记变量判断兔子是否休息（下标对应时间），用一个数组判断兔子休息的时间段。当兔子或乌龟的路程达到比赛路程l时，就表示比赛结束，相同时间下，谁的路程远就谁胜利。大致就是这样，需要注意兔子休息之后，如果不加判断变量flag，可能会再次判断兔子是否超过乌龟t米，在这上面纠结了好一会，后来终于AC了。╮(─▽─)╭

AC代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <stdio.h>
#include <string.h>
int main(){
int v1,v2,t,s,l,j,i=0;
int sr[10000],st[10000];//分别表示兔子走的路程和乌龟的路程 
memset(sr,0,sizeof(sr));
memset(st,0,sizeof(st));
scanf("%d%d%d%d%d",&v1,&v2,&t,&s,&l);
int tot[10000];
memset(tot,0,sizeof(tot));

i=1;
int flag=0;
while(sr[i]!=l && st[i]!=l){//两者都没有到达终点 
if(tot[i]==0){
sr[i]=sr[i-1]+v1;
flag=0;
} 
else
sr[i]=sr[i-1];

st[i]=st[i-1]+v2;
if(!flag && tot[i]!=1){//用flag变量防止兔子休息过程中再次判断是否休息 
if(sr[i]-st[i]>=t){
flag=1; 
for(j=i+1;j<=i+s;j++){
tot[j]=1;//标志兔子休息 
}
}
}

if(sr[i]>=l || st[i]>=l)
break;
i++;
}

if(sr[i]>st[i]){//相同的时间内，看谁的路程远，谁先到 
printf("R\n%d\n",i);
}
else if(sr[i]<st[i])
printf("T\n%d\n",i);
else
printf("D\n%d\n",i);
return 0;
}

可能方法相较于其他的大佬比较繁琐，不过做出来就好了，菜鸡继续学习ing(#^.^#)

问题描述
　　有n（2≤n≤20）块芯片，有好有坏，已知好芯片比坏芯片多。
　　每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。
　　给出所有芯片的测试结果，问哪些芯片是好芯片。
输入格式
　　输入数据第一行为一个整数n，表示芯片个数。
　　第二行到第n+1行为n*n的一张表，每行n个数据。表中的每个数据为0或1，在这n行中的第i行第j列（1≤i, j≤n）的数据表示用第i块芯片测试第j块芯片时得到的测试结果，1表示好，0表示坏，i=j时一律为1（并不表示该芯片对本身的测试结果。芯片不能对本身进行测试）。
输出格式
　　按从小到大的顺序输出所有好芯片的编号
样例输入
3
1 0 1
0 1 0
1 0 1
样例输出
1 3

思路：
刚看到这道题是没有思路的，想着假设1号芯片是好的再一一比对，有点麻烦。后来在网上搜，发现简便方法，利用离散中的抽屉原理（还没学过）。

抽屉原理：如果把n+1个物体放入n个抽屉里，则必有一个抽屉里至少放了两个物体。

在这道题中的应用就是假如有n/2个芯片说某一个芯片是好的的话，那该芯片就是好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <stdio.h>
#include <string.h> 
int main(){
int n,i,j;
scanf("%d",&n);
int a[22][22],count[22];
memset(count,0,sizeof(count));//初始化 
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
scanf("%d",&a[i][j]);

for(i=1;i<=n;i++){
for(j=1;j<=n;j++){
if(i!=j && a[i][j]==1)
count[j]++;
}
}
for(j=1;j<=n;j++)
if(count[j]>=n/2)
printf("%d ",j);
return 0;
}

问题描述
　　平面上有两个矩形，它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形，我们给出它的一对相对顶点的坐标，请你编程算出两个矩形的交的面积。
输入格式
　　输入仅包含两行，每行描述一个矩形。
　　在每行中，给出矩形的一对相对顶点的坐标，每个点的坐标都用两个绝对值不超过10^7的实数表示。
输出格式
　　输出仅包含一个实数，为交的面积，保留到小数后两位。
样例输入
1 1 3 3
2 2 4 4
样例输出
1.00

思路：
（1）如果两个矩形相交，

如图，可以发现，我们只要求出两个矩形相交的主对角线的交点坐标，然后计算面积即可。观察图可以发现，A点横坐标是两个矩形两个小的横坐标的最大值，而B点横坐标是两个矩形两个大的横坐标的最小值，纵坐标类似，就可以求出矩形的长和宽了。
（2）若两个矩形不相交，上面的方法就不行了，通过计算得到的交点坐标如下图，很明显是不对滴，所以需要另行判断

AC代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <stdio.h>
double max(double a,double b){
if(a>b)
return a;
else
return b;
}
double min(double a,double b){
if(a<b)
return a;
else
return b;
}
int main(){
double x1,x2,x3,x4,y1,y2,y3,y4,s;
scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
scanf("%lf%lf%lf%lf",&x3,&y3,&x4,&y4);
double m1,n1,m2,n2;//两个交点的坐标 
if(max(x1,x2)<=min(x3,x4) || max(x3,x4)<=min(x1,x2))
printf("0.00\n");
else{
m1=max(min(x1,x2),min(x3,x4));
m2=min(max(x1,x2),max(x3,x4));
n1=min(max(y1,y2),max(y3,y4));
n2=max(min(y1,y2),min(y3,y4));
s=(m2-m1)*(n1-n2);
printf("%.2lf\n",s);
}
return 0;
}

Input
输入数据有多组，每组占一行，包含两个正整数n和m，n和m的含义如上所述。

Output
对于每组输入数据，输出一个平均值序列，每组输出占一行。

Sample Input

3 2
4 2

Sample Output

3 6
3 7

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>

int main(){
int n,m,i;
int a[101],b[101];
while(scanf("%d%d",&n,&m)!=EOF){
if(n>0 && n<=100){
int count=0,sum=0,k=0;
for(i=0;i<n;i++)
a[i]=(i+1)*2;
for(i=0;i<n;i++){
count++;
sum+=a[i];
//每隔m个数计算一次
if(count==m){
b[k++]=sum/m;
sum=0;
count=0;
}
}
if(n%m!=0){
b[k]=sum/(n%m);
k++;//保证数组b正常输出
}
for(i=0;i<k-1;i++){
printf("%d ",b[i]);
}
printf("%d\n",b[k-1]);
}
}
return 0;
}

Description
筒子想求出若干个数每个数的阶乘，请你帮他吧！
Input
若干数N（0<=N<=20）
Output
每个数的阶乘

Sample Input 1
1
2
3

Sample Output 1
1
2
6

阶乘本来很容易实现，但是多组数的阶乘纠结了一会，其实这就回到了多组输入输出的问题，利用文件结束标志EOF将判断条件设为scanf("%d",&n)!=EOF就OK了。
还有一个就是要注意，因为是计算多组数的阶乘，所以在每次计算一个n的阶乘之前，都要把s重新赋为1，切记！！！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>
int main(){
  int n,i;
  long s=1;
  while(scanf("%d",&n)!=EOF){
  if(n<=1){
  s=1;
  printf("%ld\n",s);
}
else{
s=1;//将s重新赋为1
for(i=1;i<=n;i++){
s*=i;
}
printf("%ld\n",s);
}
}
  return 0;
}

问题描述
　　最近FJ为他的奶牛们开设了数学分析课，FJ知道若要学好这门课，必须有一个好的三角函数基本功。所以他准备和奶牛们做一个“Sine之舞”的游戏，寓教于乐，提高奶牛们的计算能力。
　　不妨设
　　An=sin(1–sin(2+sin(3–sin(4+…sin(n))…)
　　Sn=(…(A1+n)A2+n-1)A3+…+2)An+1
　　FJ想让奶牛们计算Sn的值，请你帮助FJ打印出Sn的完整表达式，以方便奶牛们做题。
输入格式
　　仅有一个数：N<201。
输出格式
　　请输出相应的表达式Sn，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
样例输入
3
样例输出
((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1

仔细观察An和Sn，是有规律的，用代码实现出来：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <stdio.h>
void An(int n){
int i;
for(i=1;i<=n;i++){
printf("sin(%d",i);
if(i%2!=0 && i!=n)
printf("-");
if(i%2==0 && i!=n)
printf("+");
}
for(i=0;i<n;i++)
printf(")");
} 

void Sn(int n){
int i,d;
d=n;
for(i=0;i<n-1;i++)
printf("(");
for(i=1;i<=n;i++){
An(i);
printf("+%d",d);
if(d!=1)
printf(")");
d--;
}
}

int main(){
int n;
scanf("%d",&n);
Sn(n);
return 0;
}

斐波那契数列问题

Description

斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda
Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递推的方法定义：F(1)=1，F(2)=1,
F(n)=F(n-1)+F(n-2)（n>=3，n∈N*）现在给你一个整数n(n>=1),求斐波那契数列中第n项的值.

Input 一个正整数n(n<=92)

Output 一个正整数

如此出名的问题自然有多种解决方案，下面列举两种比较好理解的：

1. 递归
   递归的缺点就是容易超时，但是代码易懂，简短。OJ上提交会Time out。

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

   #include <stdio.h> long F(int n){ if(n<=2) return 1; else return F(n-2)+F(n-1);//递归 } int main(){ int n; scanf("%d",&n); printf("%ld",F(n)); return 0; }

2. 循环
   在各大OJ上提交这种一般是没问题的，不会超时。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

   #include <stdio.h> long F(int n){ long f0=0,f1=1; if(n==0) return f0; if(n==1) return f1; long fn=0; int i; for(i=2;i<=n;i++){ fn=f0+f1; f0=f1; f1=fn; } return fn; } int main(){ int n; scanf("%d",&n); printf("%ld",F(n)); return 0; }

欢迎大佬批评指正~~

其中，蜂房的结构如下所示。

Input
输入数据的第一行是一个整数N,表示测试实例的个数，然后是N 行数据，每行包含两个整数a和b(0<a<b<50)。

Output
对于每个测试实例，请输出蜜蜂从蜂房a爬到蜂房b的可能路线数，每个实例的输出占一行。

Sample Input
2
1 2
3 6

Sample Output
1
3

这是一道递推的题，观察给出的图形，只有上下两行，容易想到1→2，3→4相当于一样的走法，这就涉及减法相同的问题了。那就只考虑从1到别的蜂房，1→2 1→3 1→4 1→5分别输出1 2 3 5，这就是斐波那契数列了，直接上代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <stdio.h>
int main(void){
int t;
long long f[55];
f[1]=1;
f[2]=2;
for(int i=3;i<55;i++){
f[i]=f[i-1]+f[i-2];
}
scanf("%d",t);
while(t--){
int n,m;
scanf("%d%d",&n,&m);
printf("%lld\n",f[m-n]);
}
return 0;
}

或者使用斐波那契数列的通项公式来求，不过要注意公式中n的取值，因为数列：1 1 2 3 5 ……，我们不需要第一项。

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
#include <math.h>
int main(void){
int n,a,b;
scanf("%d",&n);
while(n--){
scanf("%d%d",&a,&b);
printf("%.0f\n",1.0*(pow((1+sqrt(5))/2.0,b-a+1)-pow((1-sqrt(5))/2.0,b-a+1))/sqrt(5));
}
return 0;
}

题目描述：

有n个小朋友做游戏，他们的编号分别是1,2,3…n。他们按照编号从小到大依次顺时针围成一个圆圈，第一个小朋友从1开始报数，依次按照顺时针方向报数（报数的值加一），每个报m的人会离开队伍，然后下一个小朋友会继续从1开始报数，直到只剩下一个小朋友为止。

求最后一位小朋友的编号。

Input
输入两个数字n，m(1<=m<=n<100000)，用空格隔开。
Output
输出最后一个小朋友的编号，独占一行。

Sample Input 1

7 5
Sample Output 1

6

仔细分析，用数组，循环解决：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include<stdio.h>
#include<stdlib.h>
int main()
{
int n,k,i;//总人数n，跳出数字k 
scanf("%d%d", &n, &k);
int *arr=(int*)calloc(n,sizeof(int));//分配大小为n的空间，并赋初值0 

for(i=0;i<n;i++){//给这组数赋值 
arr[i]=i+1;
}
int t=0,num=n;//计数变量
for(i=1; ;i++){
if(i>n)//回溯，从头开始计数 
i=1;

if(arr[i-1]!=0)//计数直到跳出数字k 
++t;

if(t==k){
arr[i-1]=0;
--num;
t=0;
} 
if(num==1)//只剩一人跳出循环 
break;
} 
//找出最后剩余的一位输出来 
for(i=0;i<n;i++){
if(arr[i]!=0){
printf("%d",arr[i]);
break;
}
}
return 0;
}

百度借鉴大佬的代码，不用数组，用链表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include<stdio.h>  
#include<stdlib.h>  
typedef struct List  
{  
    int  data;  
    struct List *next;  
}list;  
   
int main()  
{
list *L = (list*)calloc(1, sizeof(list));//头结点
L->next = NULL;
int n, k, i;
scanf("%d%d", &n, &k);
 
list *s, *q = L;
for (i=0; i<n; ++i)//赋初值
{
s = (list*)calloc(1, sizeof(list));
s->data = i+1;
s->next = NULL;
q->next = s;
q = s;
}
 
q->next = L->next;//让尾结点指向头结点的下一个，即第一个人的位置，单向循环链表创建完成
q = L->next;//让q指向头结点的下一个
 
while (q->next != q)//只剩一个元素时，退出循环
{
for (i=1; i<k-1; ++i)
{q = q->next;}//q指向删除节点的前一个
s = q->next;//s指向删除节点
q->next = s->next;//将去除s后的链表重新连接起来
q = q->next;//让q指向下次循环的起始位置
//printf("%d ", s->data);
free(s);
s = NULL;
}
 
printf ("%d\n", q->data);
free(q);
q = NULL;
free(L);
L = NULL;
return 0;
}

后来还有大佬写出迄今为止看到的最短小版本 tql：

1
2
3
4
5
6
7
8
9
10

#include<stdio.h> 
int main(){ 
  int n, k, i, s = 0; 
  scanf("%d%d", &n, &k); 
  for (i = 2; i <= n; ++i){ 
    s = (s+k)%i; 
  } 
  printf("%d\n", s+1); 
  return 0; 
}

小李的店里专卖其它店中下架的样品电视机，可称为：样品电视专卖店。
其标价都是4位数字（即千元不等）。
小李为了标价清晰、方便，使用了预制的类似数码管的标价签，只要用颜色笔涂数字就可以了（参见图片）。

这种价牌有个特点，对一些数字，倒过来看也是合理的数字。如：1 2 5 6 8 9 0 都可以。这样一来，如果牌子挂倒了，有可能完全变成了另一个价格，比如：1958 倒着挂就是：8561，差了几千元啊!!
当然，多数情况不能倒读，比如，1110 就不能倒过来，因为0不能作为开始数字。
有一天，悲剧终于发生了。某个店员不小心把店里的某两个价格牌给挂倒了。并且这两个价格牌的电视机都卖出去了!
庆幸的是价格出入不大，其中一个价牌赔了2百多，另一个价牌却赚了8百多，综合起来，反而多赚了558元。

请根据这些信息计算：赔钱的那个价牌正确的价格应该是多少？

Input
None

Output
一个4位数字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include <stdio.h>
#include <math.h>
int main()
{
     int Na, Nb;
     int num = 0;
     for (int i = 9999; i >= 1000; i--)//倒立后的价格
          for (int j = 1025; j <= 9999; j++)
          {
               int     m = i, n = j;
               int     a[4], b[4];
               for ( int q = 0; q < 4; q++ )   // 真正价格 倒序存入数组
               {
                    int     cheakA= m % 10;
                    int     cheakB= n % 10;
 
                    /* 6 9 对换 ！！！ */
                    if ( cheakA == 6 )
                         cheakA = 9;
                    else if ( cheakA == 9 )
                         cheakA = 6;
                    if ( cheakB == 6 )
                         cheakB = 9;
                    else if ( cheakB == 9 )
                         cheakB = 6;

                    a[q]     = cheakA;
                    b[q]     = cheakB;

                    m     = m / 10;
                    n     = n / 10;
               }
 
 
               if (a[0] != 0 && a[0] != 3 && a[0] != 4 && a[0] != 7 && b[0] != 0 && b[0] != 3 && b[0] != 4 && b[0] != 7)
                    if (a[3] != 0 && a[3] != 3 && a[3] != 4 && a[3] != 7 && b[3] != 0 && b[3] != 3 && b[3] != 4 && b[3] != 7)
                         if (b[1] != 3 && b[1] != 4 && b[1] != 7 && b[2] != 3 && b[2] != 4 && b[2] != 7)
                              if (a[1] != 3 && a[1] != 4 && a[1] != 7 && a[2] != 3 && a[2] != 4 && a[2] != 7)
                              {
                                   Na = 0; Nb = 0;
                                   for (int w = 0; w < 4; w++) //倒序前的价格
                                   {//几个数字转化为一个数
                                        Na= Na * 10 + a[w];
                                        Nb= Nb * 10 + b[w];
                                   }
 
                                   if ((i - Na) > 800 && (Nb - j) > 200 && (i - Na) < 900 && (Nb - j) < 300)
                                   {
                                        if ( (i - Na) - (Nb - j) == 558 )
                                        {
                                             num++;
                                             printf( "倒立后：%d赚钱真实价钱：%d\n", i, Na );
                                             printf( "倒立后：%d赔钱真实价钱：%d\n", j, Nb );
                                             printf( "\n" );
                                        }
                                   }
                              }
          }
     printf( "%d", num );
     return(0);
}

百度了一下，还有用两种数组来做的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include<stdio.h>   
#include<math.h>  
  
int main(){  
    int num1[7]={0,1,2,5,6,8,9},num2[7]={0,1,2,5,9,8,6};//因为6要变成9，9要变成6，所以定义两个数组，6 9位置颠倒   
    int a,b,c,d,i,j,k,m;  
    int p1,p3,diff1,p2,diff2;//p1,p3表示赔二百的，p2表示挣八百的   
    for(a=1;a<7;a++){  
        for(b=0;b<7;b++){  
            for(c=0;c<7;c++){  
                for(d=1;d<7;d++){  
                    p1=num1[a]*1000+num1[b]*100+num1[c]*10+num1[d];  
                    p3=num2[d]*1000+num2[c]*100+num2[b]*10+num2[a];  
                    diff1=fabs(p1-p3);   
                    if(diff1>200&&diff1<300){  
                        for(i=1;i<7;i++){  
                            for(j=0;j<7;j++){  
                                for(k=0;k<7;k++){  
                                    for(m=1;m<7;m++){  
                                        p2=num1[i]*1000+num1[j]*100+num1[k]*10+num1[m];  
                                        diff2=fabs(p2-(num2[m]*1000+num2[k]*100+num2[j]*10+num2[i]));   
                                        if(diff2>800&&diff2<900&&fabs(diff1-diff2)==558){  
                                            if(p1<p3){  
                                                printf("%5d",p3);  
                                                return 0;  
                                            }else{  
                                                printf("%5d",p1);  
                                                return 0;  
                                            }  
                                                  
                                        }  
                                    }  
                                }  
                            }  
                        }  
                    }  
                }  
            }  
        }  
    }   
    return 0;  
}

莫的感情的搬运机器QAQ

大数学家高斯有个好习惯：无论如何都要记日记。

他的日记有个与众不同的地方，他从不注明年月日，而是用一个整数代替，比如：4210

后来人们知道，那个整数就是日期，它表示那一天是高斯出生后的第几天。这或许也是个好习惯，它时时刻刻提醒着主人：日子又过去一天，还有多少时光可以用于浪费呢？

高斯出生于：1777年4月30日。

在高斯发现的一个重要定理的日记上标注着：5343，因此可算出那天是：1791年12月15日。

高斯获得博士学位的那天日记上标着：8113

请你算出高斯获得博士学位的年月日。

注意：只提交这个日期，不要输出其它附加内容，比如：说明性的文字。

Input
None

Output
提交答案的格式是：yyyy-mm-dd, 例如：1980-03-21（这个不是答案！！！！）

原本一着急就纯手算了，还好数学计算能力还行，算起来不费劲，后来改代码运算：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <stdio.h>
int main(){
int year=1777,mon=4,day=30;//起始日期
int d;
bool run=0;//定义闰年
for(d=1;d<8113;d++){
//判断闰年 
if(year%4==0 && year%100!=0 || year%400==0)
run=1;
else
run=0;
//在每月月底，将day置1；年底将mon，day都置1
if(run==1 && mon==2 &&day==29){
mon++;
day=1;
}
else if(run==0 && mon==2 && day==28){
mon++;
day=1;
}
else if((mon==1 || mon==3 || mon==5 || mon==7 || mon==8 || mon==10) && day==31){
mon++;
day=1;
}
else if((mon==4 || mon==6 ||mon==9 || mon==11) && day==30){
mon++;
day=1;
}
else if(mon==12 &&day==31){
year++;
mon=1;day=1;
}
else{
day++;
}
printf("%d-%d-%d\n",year,mon,day);
} 

return 0;
}

答案：1799-07-16（一定要注意07！！！）

问题描述
　　给定一个1～N的排列a[i]，每次将相邻两个数相加，得到新序列，再对新序列重复这样的操作，显然每次得到的序列都比上一次的序列长度少1，最终只剩一个数字。
　　例如:
　　3 1 2 4
　　4 3 6
　　7 9
　　16
　　现在如果知道N和最后得到的数字sum，请求出最初序列a[i]，为1～N的一个排列。若有多种答案，则输出字典序最小的那一个。数据保证有解。
输入格式
　　第1行为两个正整数n，sum
输出格式
　　一个1～N的一个排列
样例输入
4 16
样例输出
3 1 2 4
数据规模和约定
　　0<n<=10

思路

一看 n<=10那直接暴力了。
使用vector容器，借助C++中next_permutation()函数，升序列举出所有的全排列序列，然后循环对每个序列都操作并判断，如果找到，就break即可。
这里一次操作其实就是把1~n-1下标的元素，依次加上它后面的元素，这个操作重复n-1次即可，最后判断数组下标0和结果sum是否相等即可。

用到的函数：
next_permutation函数将按字母表顺序生成给定序列的下一个较大的排列，直到整个序列为降序为止。prev_permutation函数与之相反，是生成给定序列的上一个较小的排列。
这是一个求一个排序的下一个排列的函数，可以遍历全排列,要包含头文件<algorithm>
使用方法：next_permutation(数组头地址，数组尾地址);若下一个排列存在，则返回真，如果不存在则返回假。

百度解释：
boolean next_permutation(a.begin(),a.end())
该函数是以输入字符串中的字符所构建的按字典顺序全排列中，判断当前字符串之后是否还有下一个字符串。如果next_permutation的执行次数少于全排列的个数，返回true。

例如 a=”abc” 全排列有 “abc” “acb” “bac” “bca” “cab” “cba”
执行一次next_permutation 返回true a变成 “acb”
再执行一次next_permutation 返回true a变成 “bac”
…
当执行到a=”cba” 时 由于这已经是全排列的最后一个字符串，所以 再次执行next_permutation 则返回false

AC代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n,sum,i,j,sum1=0;
cin>>n>>sum;
vector<int> a(n);
for(int i=0;i<n;i++)
a[i]=i+1;
do{
vector<int> b=a;//将数组a复制给b 
for(int i=0;i<n-1;i++)
for(int j=0;j<n-i-1;j++)
b[j]+=b[j+1];//b[0]=b[0]+b[1],b[1]=b[1]+b[2]...
if(b[0]==sum){
for(int i=0;i<n;i++)
cout<<a[i]<<" ";
cout<<endl;
break;
}
}while(next_permutation(a.begin(),a.end()));//产生下一个排列，循环即进行全排列
return 0;
}