11.1474B
题解备份

#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
//1474B
//题目大意
//T组读入 每组一个d 1<=d<=1e4
//要求输出一个数 这个数至少有四个因数 且每个因数的差>=d
/*----------------解题思路--------------------*/
// 观察样例可知 四个因数包括1和答案本身
// 所以 只要找到满足条件的中间两个因数就能得到答案
// 尝试了ans=(1+d)*(2d+1)的方案 失败告终
// 随后发现 上面的方案是会存在其他因数的 由此会导致因数间的差小于d
// 那么就是要找到某两个因数 p,q p-1>=d q-p>=d p*q还不能有除了1 小于q的因数
// 那么pq只要是质数就能满足条件 
// 说干就干 质数筛筛出质数 随后找到>=1+d的第一个质数p
// 再找到q p*q就是答案 
typedef long long ll;
const int N = 5e4+10;
int T,n;
int cnt,primes[N];
bool st[N];
void get_primes(int n){
    for (int i=2;i<=n;i++){
        if (!st[i]) primes[cnt++]=i;
        for (int j=0;primes[j]<=n/i;j++){
            st[primes[j]*i]=1;
            if (i%primes[j]==0) break;
        }
    }
}
int main(){
    get_primes(5e4);
    scanf("%d", &T);
    while (T--){
        int d;
        scanf("%d", &d);
        ll l,r;
        l=0;
        while (primes[l]-1<d) l++;
        r=l+1;
        while (primes[r]-primes[l]<d) r++;
        ll ans=primes[l];
        printf ("%lld\n",ans*primes[r]);

    }
    return 0;
}

12.766A
题解备份

#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
// 766A
// 题目大意
// 给定俩字符串 问这俩字符串的最长不常见子序列长度
/*------------------解题思路----------------*/
// 本质上是一个脑筋急转弯
// 不常见子序列 可能是我的翻译插件的问题 理解来很晦涩
// 实际上就是最长的在另一个字符串找不到的子序列
// 所以 只要俩字符串不一样 那么最长不常见子序列就是 长一点的那个字符串
typedef long long ll;
const int N = 1e5+10;
int main(){
    string a,b;
    int n,m;
    cin>>a>>b;
    n=a.size();
    m=b.size();
    if (a!=b) printf ("%d\n",max(n,m));
    else puts("-1");
    return 0;
}

13.1312B
题解备份

#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
//1312B
//题目大意 
//T组读入 每组一个n 再来n个数 1<=n<=100
//若设定满足 i<j i-a[i]!=j-a[j]的是好数组 请排列数组构造出一个好数组
/*---------------解题思路-----------------------*/
// 之前做过,但现在还是做不出来。。。难受。。。。
// 题目没提到构造不出的情况 意味着存在一种通解
// i<j i-a[i]!=j-a[j] 等价于i-j!=a[i]-a[j]
// 因为i<j 所以i-j必定为负数 而a[i]-a[j]>=0就能必定能使不等号成立
// 所以倒着排个序就好了
typedef long long ll;
const int N = 1e5+10;
int T,n,a[N];
bool cmp(int a,int b){
    return a>b;
}
int main(){
    scanf ("%d",&T);
    while (T--){
        scanf("%d", &n);
        for (int i=1;i<=n;i++) {
            scanf ("%d",&a[i]);
        }
        sort(a+1,a+1+n,cmp);
        for (int i=1;i<=n;i++) {
            printf ("%d ",a[i]);
        }
        puts("");
    }
    return 0;
}

14.1419D1
题解备份

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
//1419D1
//题目大意
//给定一个n 以及n个数 1<=n<=1e5
//问如何排列使得 a[i-1]>a[i]&&a[i]<a[i+!]的情况最多
//输出 满足条件的a[i]的个数 并输出排列后的数组
/*------------------------题目大意------------------*/
// 如果把最后的数组折线图来表示 那么就是一个上升的波形图
// 满足条件的a[i]的个数 就是谷底的个数=n%2?n/2:(n-1)/2;
// 排个序 开个数组存数 第一个谷底放最小的 第二个谷底放第二小的...
// 谷底放完后开始依次放谷峰
// 放完后进行判定再输出
const int N = 1e5+10;
int n,a[N];
int main(){
    scanf("%d", &n);
    for (int i=1;i<=n;i++) scanf ("%d",&a[i]);
    sort(a+1,a+1+n);
    int t[N];
    int u=n%2?n/2:(n-1)/2;
//求出n能拥有的谷底上限
    for (int i=1;i<=n;i++){
        if (i%2) t[i]=a[u+i/2+1];
        else if (i%2==0&&i/2<=u)t[i]=a[i/2];
        else t[i]=a[i];
    }
    int ans=0;
    for (int i=2;i<=n;i+=2){
        if (t[i]<t[i-1]&&t[i]<t[i+1]) ans++;
    }
    cout<<ans<<'\n';
    for (int i=1;i<=n;i++){
        cout<<t[i]<<' ';
    }
    return 0;
}

15.680B
题解备份

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
// 680B
// 题目大意
// 给定一个 n s表示城市个数与初始位置
// 随后是n个数 表示城市i的罪犯数量 数量最多为1
// 现有探测器 可以探测到距s有i个距离的城市的罪犯数量
// 问最多可以抓几个罪犯
/*----------------------解题思路------------------*/
// 对于有罪犯的城市i 其关于s的对称城市下标为ohter=s-(i-s)
// 若other<1或other>n则城市i的罪犯可以抓到
// 若1<=other<=n&&a[i]=a[other]=1则城市i与other的都可以抓到
// 只不过other的罪犯遍历到了再记入
typedef long long ll;
const int N = 1e5+10;
int n,s;
int a[N];
int main(){
    scanf("%d%d", &n,&s);
    for (int i=1;i<=n;i++){
        scanf("%d", &a[i]);
    }
    int ans=0;
    for (int i=1;i<=n;i++){
        if (a[i]){
            int other=s-(i-s);
            if (other<1||other>n||a[i]==a[other]) ans++;
        }
    }
    printf ("%d\n",ans);
    return 0;
}
/*
int main(){
    scanf("%d%d", &n,&s);
    for (int i=1;i<=n;i++){
        scanf("%d", &a[i]);
    }
    int ans=0;    
    for (int i=s*2;i<=n;i++) ans+=a[i];
    //cout<<ans<<'\n';
    if (a[s]) ans++;
    for (int i=1;i<s;i++){
        if (s-i>=1&&s+i<=n){
            if (a[s-i]&&a[s+i]) ans+=2;
        }
        else if (s-i>=1&&s+i>n){
            if (a[s-i]) ans++;
        }
        else if (s-i<1&&s+i<=n){
            if (a[s+i]) ans++;
        }
    }
    return 0;
}*/

16.1430C
题解备份

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
//1430C
// 题目大意
// T组数据 每组一个n 
// 要求合并一个数组 数组内数为1~n
// 问以合并n-1次  最终结果最小为多少 并输出每次合并的过程
// 合并操作：删除要合并的两个数x,y 插入round((x+y)/2.0)
/*-------------------------解题思路---------------------*/
// 每次只选最大的两个数合并 因为合并的规则为四舍五入 
// 所以每次只选最大的合并 会使最后的结果变小
// 值得一提的是 两个整数的四舍五入等价于上取整
// ceil 上取整 floor下取整 round四舍五入
typedef long long ll;
const int N = 1e5+10;
int T,n;
int main(){
    scanf("%d", &T);
    while (T--){
        scanf("%d", &n);
        int ans=n;
        for (int i=n-1;i>=1;i--){
            //ans=(ans+i+1)/2;
            ans=round((ans*1.0+i)/2);

        }
        printf ("%d\n",ans);
        ans=n;
        for (int i=n-1;i>=1;i--){
            printf ("%d %d\n",ans,i);
            //ans=(ans+i+1)/2;
            ans=round((ans*1.0+i)/2);
        }
    }
    return 0;
}

17.798A
题解备份

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
//798A
//题目大意
//给定一个字符串s 请判断能否在只改变一个字符的情况下变成回文字符串
/*----------------------------解题思路--------------------------*/
//一个元素u存不同的字符对数 根据字符串的奇偶性进行判断是否可变
//奇数时u<=1 偶数时u==1 
int main(){
    char s[110];
    scanf("%s", s);
    int n=strlen(s);
    int u=0;
    for (int i=n/2-1;i>=0;i--){
        if (s[i]!=s[n-i-1]) u++;
    }
    int p;
    if (n%2){
        p=u<=1?1:0;
    }
    else {
        p=u==1?1:0;
    }
    printf ("%s\n",p?"YES":"NO");
    return 0;
}

18.1579E1
题解备份

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <deque>
using namespace std;
//1579E1
//题目大意
// T组读入 每组n个数 这n个数是某双端队列的入队顺序
// 要求输出字典序最小的的排列
/*---------------------------解题思路---------------*/
// 本质数据结构考察题 不会用deque就得自己手动模拟双端队列了hh
// 尝试用string模拟tle了
// 对于第2~n个数 每个都与队头元素比较 若小于则该元素变成队头
// 否则插入队尾 最后输出即可
const int N = 2e5+10;;
int T,n,a[N];
int main(){
    scanf("%d", &T);
    while (T--){
        scanf("%d", &n);
        deque <int> ans;
        for (int i=1;i<=n;i++){
            int x;
            scanf("%d", &x);
            if (!ans.size()||x<ans.front()){
                ans.push_front(x);
            }
            else {
                ans.push_back(x);
            }
        }
        for (int x:ans){
            cout<<x<<' ';
        }
        puts("");
    }
    return 0;
}

19.1562B
题解备份

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
//1562B
// 题目大意
// T组读入 每组给你n和一个n位数 n<50
// 问怎么删使得最后的数是非质数(合数与1) 且数位最少
// 输出答案的位数 与答案
/*----------------------------解题思路----------------*/
// 首先 若数中有 1 4 6 8 9那么这些数就是答案 输出即可
// 同时 毛子证明了 只要是给出的输入 那么必然有位数<=2的答案 
// 对于两位的情况 O(n^2)枚举凑两位数 再判断就行了
typedef long long LL;
int primes[1010],cnt;
int T,n,a[110];
bool st[1010];
void get_primes(int n){
    for (int i=2;i<=n;i++){
        if (!st[i]) primes[cnt++]=i;
        for (int j=0;i<=n/primes[j];j++){
            st[primes[j]*i]=1;
            if (i%primes[j]==0) break;
        }
    }
}
bool check(int x){
    for (int i=0;x>primes[i];i++){
        if (x%primes[i]==0&&x/primes[i]>1){
            return 1;
        }
    }
    return 0;
}
int main(){
    get_primes(1000);

    bool ss[10]={0};
    ss[1]=ss[4]=ss[6]=ss[8]=ss[9]=1;

    scanf("%d", &T);
    while (T--){
        int p=0;
        scanf("%d", &n);
        for (int i=1;i<=n;i++){
            scanf("%1d", &a[i]);
            if (!p){
                if (ss[a[i]]){
                    printf ("1\n%d\n",a[i]);
                    p=1;
                }
            }
        }
        if (!p){
            for (int i=1;i<=n;i++){
                for (int j=i+1;j<=n;j++){
                    int t=a[i]*10+a[j];
                    if (check(t)){
                        p=1;
                        printf ("2\n%d\n",t);
                        break;
                    }
                }
                if (p) break;
            }
        }
    }
    return 0;
}

20.1569B
题解备份

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
//1569B
//题目大意
// T组读入 每组n个数 数代表着选手的期望情况
// 1代表不想输掉任何一场比赛
// 2代表希望至少赢一场
// 要求输出 能否实现所有选手的期望
// 若能输出满足期望的对局情况
/*----------------------------解题思路-----------------------*/
// 情况1不想输 可以都平局
// 情况2 至少赢一场 可以安排其与下一个人对战赢 其他情况不管
// 如此安排若有2 则2必须要有3+的人 否则实现不了
// 那么开个答案char数组 先初始化全= 再特判掉X
// 同时 读入2的数量 若有解则进行+ -的情况分配
// 最后输出即可
int T,n,a[110];
int main(){
    scanf("%d", &T);
    while (T--){
        char g[110][110];
        scanf("%d", &n);
        vector <int> id;
        for (int i=1;i<=n;i++){
            scanf("%1d", &a[i]);
            if (a[i]==2) id.push_back(i);
        }
        int ns=id.size();
        if (ns==1||ns==2) {
            puts("NO");
            continue;
        }
        for (int i=1;i<=n;i++){
            for (int j=i;j<=n;j++){
                g[i][j]=g[j][i]='=';
                if (i==j) g[i][j]='X';
            }
        }
        for (int i=0;i<ns;i++){
            int x=id[i],y=id[(i+1)%ns];
            g[x][y]='+',g[y][x]='-';
        }
        puts("YES");
        for (int i=1;i<=n;i++) {
            printf ("%s\n",g[i]+1);
        }
    }
    return 0;
}