前言：

当时场上没想出来，我感觉我很容易算错时间复杂度，22年的icpc济南，那道矩阵取模的题也是因为当时时间复杂度算错了结果没写。主要原因应该还是太依赖感觉了。

题目描述：

这个题的第一问是无序序列求k小值。快速选择 时间空间都是o(n)，显然没有亚线性的算法。

第二问：

有m次询问，每次询问小值要求空间复杂度不变（还是o(n)）要求时间复杂度是o(nlogm)注意m是询问次数。

思路：

很显然要考虑离线

首先发现m次询问可以先排个序，感觉很有用但好像也没什么用（当时场上想到这里就开始想用平衡树，treap之类的了）

考虑一下快速选择的平均复杂度为什么是o(n)很显然平均情况下它每层递归的复杂度应该是，等比级数求和即可。 延续一下这个思想，我们发现在快速选择的时候，每当选定一个轴，做完一轮分组以后，轴的位置可能产生移动。在快速选择中，我们会抛弃此时的轴的左边全部或者右边全部。

考虑同时处理m次询问。我们首先对m次询问进行排序，然后处理中间的那个询问，假设是第p个询问。发现当我们通过快速选择法找到中间那个询问的答案（假设是，下标为h）以后此时的数组里，第1~p-1个询问的答案都会在的左边，第p+1~m个询问的答案都在的右边。

那么我们就得到了一个子问题，假设数组是a，下标从1开始。也就是在a[1]~a[h-1]中处理 询问1~p-1和在a[h+1]~a[n]中处理 询问p+1~m。这个子问题可以通过遍历1/2个序列得到答案并获得另外两个子问题。同理，每层子问题都可以通过遍历个序列获得答案并得到两个子问题。

递归求解即可。

复杂度分析：

考虑m个询问是均匀分布的情况，分布均匀是指k小值的k在1~n中的分布。（注意，当分布不均匀的时候我们没办法像快速选择法一样抛弃部分序列，且分布不均匀的情况下，子问题规模缩减的速度会变慢。可以类比快速选择的最坏情况考虑。）

至于为什么时间复杂度是nlogm，或许可以算个级数。但是还有一种比较简单的方法：考虑一个元素最多被访问多少次，显然每次递归都会导致某个子序列被切成两半，分别给不同的两个询问。那么一个元素最多被logm个询问访问到。所以时间复杂度nlogm。

没有测试数据，代码就不写了，注意一下边界情况即可。

1.kde-plasma文件丢失无法登陆

症状主要表现为登陆界面忽然变得十分复古，并且伴随输入密码之后enter没反应，有的时候会报告文件缺失。

解决方法在于使用救援模式重新安装kde-plasma-desktop和sddm

关于sddm：这不是必须的，但是就我目前使用情况，伴随kde-plasma安装的sddm是损坏，或者至少功能不完整的。

apt remove kde-plasma-desktop
apt install kde-plasma-desktop

2.sddm设置无效

正如我前面所说，伴随kde-plasma安装的sddm是损坏，或者至少功能不完整的

这个时候只需要

apt remove sddm
apt install sddm

重启即可

1.定义

一般而言这个模型可以用来表示一个项目的子项之间的依赖关系，用来管理项目进度。

2.计算方法

计算关键路径事实上只是在DAG上的简单dp，首先计算一个事件的最早开始时间，然后计算一个事件的不会影响到最终项目进度的最晚开始时间，当最早开始时间等于最晚开始时间，那么这个点是一个关键的点。所有的关键点一定会组成一颗树。树上的所有路径都是关键路径。

首先计算拓扑序，然后在拓扑序上正向递推一个事件的最早开始时间，最后在逆拓扑序上递推最迟开始时间

第一个点的 minStartTime = 0，最后一个点的 maxStartTime = minStartTime

3.代码

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
const int MAXN = 1e6+7, INF = 0x3f3f3f3f;
template <typename _TP>
inline _TP qread(_TP &X){
    char ch=0;int w;X=0;
    while(!isdigit(ch)){w=ch=='-';ch=getchar();}
    while(isdigit(ch)){X=(X<<1)+(X<<3)+(ch^'0');ch=getchar();}
    X=w?-X:X;
    return X;
}
queue <int> q;
vector <int> v[MAXN],d[MAXN],pre[MAXN],predis[MAXN];
int ind[MAXN];
inline void adde(const int x,const int y,const int z){ 
    v[x].push_back(y);
    d[x].push_back(z);
    pre[y].push_back(x);
    predis[y].push_back(z);
    ind[y]++;
}
int topoOrder[MAXN],vis[MAXN],cntTopo=0;
void topoSort(int s){
    vis[s]=1;
    q.push(s);
    int nxt;
    while(!q.empty()){
        s = q.front();
        vis[s]=1; 
        q.pop();
        topoOrder[++cntTopo]=s;
        for(int i=0;i<v[s].size();i++){
            nxt = v[s][i];
            if(!vis[nxt]){ 
                if(!(--ind[nxt])){
                    q.push(nxt);
                }
            }
        }
    }
}
int minStart[MAXN],maxStart[MAXN],n,m;
bool iscritical [MAXN];
inline int Max(const int a,const int b){
    return a>b?a:b;
}
inline int Min(const int a,const int b){
    return a<b?a:b;
}
inline void PRINT(const int *tmp){
    for(int i=1;i<=n;i++){
        cout<<tmp[i]<<' ';
    }
    cout<<'\n';
}
int main(){
    int x,y,z;
    qread(n);qread(m);
    for(int i=1;i<=m;i++){
        qread(x);qread(y);qread(z);
        adde(x,y,z);
    }
    int s=1;        //start node
    topoSort(s);
    cout<<"topoOrder: ";
    PRINT(topoOrder); 
    int now,nxt;
    for(int i=1;i<=n;i++){
        now = topoOrder[i];
        for(int j=0;j<v[now].size();j++){
            nxt = v[now][j];
            minStart[nxt] = Max(minStart[nxt],minStart[now]+d[now][j]);
        }
    }
    cout<<"minStart: ";
    PRINT(minStart); 
    memset(maxStart,0x3f,sizeof(maxStart));
    maxStart[topoOrder[n]] = minStart[topoOrder[n]];
    for(int i=n;i>=1;i--){
        now = topoOrder[i];
        for(int j=0;j<pre[now].size();j++){
            nxt = pre[now][j];
            maxStart[nxt] = Min(maxStart[nxt],maxStart[now]-predis[now][j]);
        }
    }
    cout<<"maxStart: ";
    PRINT(maxStart); 
    for(int i=1;i<=n;i++){      //go through all edges
        for(int j=0;j<v[i].size();j++){
            nxt = v[i][j];
            int minHappen = minStart[i];
            int maxHappen = maxStart[nxt]-d[i][j];
            if(maxHappen - minHappen == 0){
                iscritical[i] = iscritical [j] = true;
            }
        }
    }
    cout<<"critical point: ";
    for(int i=1;i<=n;i++){
        if(iscritical[i])cout<<i<<' ';
    }
    return 0;
}

4.样例

10 14
1 2 5
1 3 6
2 5 3
3 5 6
3 4 3
4 5 3
4 7 1
4 8 4
5 6 4
5 7 2
6 10 4
7 9 5
8 9 2
9 10 2

第一行n,m是点的数量和边的数量

样例来自王道数据结构考研复习指导的习题13

1.1 题目描述

这天，小明在组装齿轮。

他一共有 个齿轮，第 个齿轮的半径为 , 他需要把这 个齿轮按一定顺序从左到右组装起来，这样最左边的齿轮转起来之后，可以传递到最右边的齿轮，并且这些齿轮能够起到提升或者降低转速（角速度）的作用。

小明看着这些齿轮，突然有 个疑问: 能否按一定顺序组装这些齿轮使得最右边的齿轮的转速是最左边的齿轮的 倍?

1.2 输入格式

输入共 行，第一行为两个正整数 , 表示齿轮数量和询问数量。

第二行为 个正整数 ，表示每个齿轮的半径。

后面 行，每行一个正整数 表示询问。

1.3输出格式

行，对于每个询问，如果存在至少一种组装方案满足条件，输出 YES, 否则输出 NO。

样例输入

5 3
4 2 3 3 1
2
4
6

样例输出

YES
YES
NO

提示

【样例说明】

询问 方案之一：23341。

询问 方案之一：42331。

询问 没有方案。

【评测用例规模与约定】

对于 的数据，保证 ;

对于 的数据，保证 ;

对于 的数据，保证 。

0.参考文献

参考文献

1.FWT的定义与证明

首先fwt是解决一类二进制下与或非运算的卷积问题的

也就是形如 使用fwt可以nlogn的进行计算

但是实际上似乎遇到一些任意进制下且不进位的卷积操作都可以考虑使用这种思想进行处理

2.代码

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define int long long
const int INF = 0x3f3f3f3f,MAXN = 1<<17|1,P = 998244353;
int n,inv2=(P+1)>>1;
template <typename _TP>
inline _TP qread(_TP &X){
    char ch=0;int w;X=0;
    while(!isdigit(ch)){w=ch=='-';ch=getchar();}
    while(isdigit(ch)){X=(X<<1)+(X<<3)+(ch^48);ch=getchar();}
    X=w?-X:X;
    return X; 
}
int A[MAXN],B[MAXN],a[MAXN],b[MAXN];
inline void cpy(){
    memcpy(a,A,sizeof(A));
    memcpy(b,B,sizeof(B));
}
inline void mul(){
    for(int i=1;i<=n;i++){
        a[i]=(a[i]*b[i])%P;
    }
}
inline void PRINT(){
    for(int i=1;i<=n;i++){
        cout<<a[i]<<" ";
    }
    cout<<'\n';
}
inline void fwtOr(int *a,const int opt){
    for(int i=1;i<n;i<<=1){
        for(int p=i<<1,j=1;j<=n;j+=p){
            for(int k=0;k<i;k++){
                a[i+j+k]=(a[i+j+k]+a[j+k]*opt+P)%P;
            }
        }
    }
}
inline void fwtAnd(int *a,const int opt){
    for(int i=1;i<n;i<<=1){
        for(int p=i<<1,j=1;j<=n;j+=p){
            for(int k=0;k<i;k++){
                a[j+k]=(a[j+k]+a[i+j+k]*opt+P)%P;
            } 
        } 
    } 
}
inline void fwtXor(int *a,const int opt){
    for(int i=1;i<n;i<<=1){
        for(int p=i<<1,j=1;j<=n;j+=p){
            for(int k=0;k<i;k++){
                int X=a[j+k],Y=a[i+j+k];
                a[j+k]=(X+Y)%P;
                a[i+j+k]=(X+P-Y)%P;
                a[j+k]=(a[j+k]*opt)%P;
                a[i+j+k]=(a[i+j+k]*opt)%P;
            }
        }
    }
}
signed main(){
    qread(n);
    n=1<<n;
    for(int i=1;i<=n;i++){
        qread(A[i]);
    }
    for(int i=1;i<=n;i++){
        qread(B[i]);
    }
    cpy();fwtOr(a,1),fwtOr(b,1),mul(),fwtOr(a,-1),PRINT();
    cpy();fwtAnd(a,1),fwtAnd(b,1),mul(),fwtAnd(a,-1),PRINT();
    cpy();fwtXor(a,1),fwtXor(b,1),mul(),fwtXor(a,inv2),PRINT();
    return 0;
}

1.1 题目描述

In the Lonely Mountain, there are a lot of treasure well protected by dwarfs. Later, one day, the last dragon Smaug came and sensed the treasure being. As known to all, dragons are always much too greedy for treasure. So definitely, the war between dwarfs and Smaug begins.

During the war, two goblins Alice and Bob are turned into frogs by Gandalf, The Grey. In front of them, there are nnn lotus leaves in a line. In order to break the spell, they must jump from the 1-st lotus leaf to the nnn-th lotus leaf. If the frog is now on the i-th lotus leaf instead of the n-th lotus leaf, it can jump to a lotus leaf in range .

Goblins are lack of intelligence and it’s also true even after turned into frogs. So Alice and Bob will jump randomly, which means, they will separately pick an available lotus leaf in every jump uniformly at random.

Since Alice and Bob have already being playing games for decades, so they want to know the probability that they jump to the nnn-th lotus leaf with the same count of jumps.

1.2 输入描述:

The first line contains an integer n (2≤n≤8 000), denoting the number of lotus leaf.

The second line contains n−1 integers ,…,, where the i-th integer (1≤≤n−i) indicates the range of lotus leaves that can be reached from the i-th lotus leaf.

1.3输出描述:

Output a line containing a single integer, indicating the probability that Alive and Bob jump to nnn-th lotus leaf with the same count of jumps, taken modulo 998,244,353.

Formally speaking, let the result, which is a rational number, be as an irreducible fraction, you need to output x⋅y−1 mod 998 244 353, where y−1 is a number such that . You may safely assume that such always exists.

2.1 状态设计与转移方程

显而易见的我们可以得到一个 o() 的状态设计和转移方程。令表示跳了i次恰好跳到j这个位置的概率。所求答案是 显而易见的转移方程是： 在这个过程中注意取模， 要变成 inv(a[j])。这一部分可以线性的预处理出来

2.2 优化

我们不能接受o() 的时间复杂度与o()的空间复杂度。在方程中枚举k是为了给后面的区间全部加上一个值。我们可以容易的想到使用前缀和进行优化。

当然还可以更轻易地想到使用滚动数组优化以后再使用树状数组或线段树一类的数据结构维护区间信息，当然这样会t，别问怎么知道的

只需要给需要区间加的区间的左端点加上要加的值，在右端点减去这个值。求前缀和的时候就完成了区间加的操作。

另外需要使用滚动数组优化空间复杂度。

1.题意

地址:https://vjudge.net/problem/UVA-10900

The player starts with a prize of $1, and is asked a sequence of n questions. For each question, he may • quit and keep his prize. • answer the question. If wrong, he quits with nothing. If correct, the prize is doubled, and he continues with the next question. After the last question, he quits with his prize. The player wants to maximize his expected prize. Once each question is asked, the player is able to assess the probability p that he will be able to answer it. For each question, we assume that p is a random variableniformly distributed over the range t..1.

大致意思是：参加有奖竞赛，初始有1$，之后每答对一题奖金翻倍，对于每个题答对的概率为[t,1]，如果答对，奖金翻倍，答错当场退赛且没有奖金，放弃答题则拿走已经得到的奖金退赛。求玩家在最优策略下奖金期望的最大值

2.解法

这个题最大的问题就在于答对的概率p不是一个定值。

我们不妨先看看p一定的情况。

设 d[i] 为已经答对了i道题的情况下，这场比赛在最优策略下的期望奖金，很显然答案为 d[0]

那么转移方程为 也就是放弃答题和继续答题两种策略取最大值

那么如果概率不是一个定值应该怎么办

根据连续概率

很显然，这是个分段函数，所以积分的结果等于两段函数分别的积分的和

当 时，

求解之后

我认为这个题的难点在于dp方程中状态的设计

3.代码

#include <iostream>
#include <cstdio>
using namespace std;
const int MAXN = 5e1+7;
double d[MAXN];
template <typename _TP>
inline _TP qread(_TP &X){
    char ch=0;int w;X=0;
    while(!isdigit(ch)){w=ch=='-';ch=getchar();}
    while(isdigit(ch)){X=(X<<1)+(X<<3)+(ch^48);ch=getchar();}
    X=w?-X:X;
    return X;
}
inline double Max(const double a,const double b){
    return a>b?a:b; 
} 
void solve(const int n,const double t){
    d[n]=1<<n;
    for(int i=n-1;i>=0;i--){
        double p0=Max(t,(double)(1<<i)/d[i+1]);
        double p=(p0-t)/(1-t);
        d[i]=(1<<i)*p+(1+p0)/2*d[i+1]*(1-p);    //积分 
    }
    printf("%.3lf\n", d[0]);
}
int main(){
    int n;
    double t;
    while(true){
        scanf("%d%lf",&n,&t); 
        if(n==0 && t==0)break;
        solve(n,t); 
    }
    return 0;
} 

1.题意

地址：https://vjudge.net/problem/AtCoder-arc098_b

2.思路

异或和这种东西，往往出了就要找一点小性质，但一般有不会很难。

性质

这个题首先异或和等于和，考虑二进制下的加法，如果异或和等于和的话，那么这些数的任意一个相同的位都不会同事出现1个以上个1。

比如说8 4 1这三个数

二进制下：

这三个数的任意相同位上都没有超过一个1。他们的和等于异或和。

判断方法很简单，只要把它们全都 & 一下如果结果不是0就一定有某些位出现了一个以上的1

所以对于一个连续子串，如果把他们全都&起来答案为0那么他们的异或和等于和

优化

很显然过不了1e5所以要优化。

可以尺取

因为很显然以a[i]为开头的连续子串的结尾位置j一定小于等于以a[i+1]为开头的子串的结尾位置。因为少&一个数总不可能加剧&出非0数

3：代码

#include <iostream>
#include <cstdio>
using namespace std;
const int MAXN = 2e5+7;
int a[MAXN];
template <typename _TP>
inline _TP qread(_TP &X){
    char ch=0;int w;X=0;
    while(!isdigit(ch)){w=ch=='-';ch=getchar();}
    while(isdigit(ch)){X=(X<<1)+(X<<3)+(ch^48);ch=getchar();}
    X=w?-X:X;
    return X;
}
inline int Max(const int a,const int b){
    return a>b?a:b;
}
int main(){
    int n;
    qread(n);
    for(int i=1;i<=n;i++){
        qread(a[i]);
    }
    int res = 0,p = 1,q = 1;
    long long ans = 0;
    while(true){
        if(p>q)q=p;
        while(!(a[q]&res) && q<=n){
            res^=a[q++];
        }
        ans+=q-p;
        res^=a[p];
        if(++p>n)break;
    }
    cout<<ans;
    return 0;
}

1.题意:

地址：https://www.luogu.com.cn/problem/P4141

ftiasch 有 n 个物品, 体积分别是 。由于她的疏忽，第 i个物品丢失了。

“要使用剩下的 n-1 物品装满容积为 x 的背包，有几种方法呢？”——这是经典的问题了。

她把答案记为 ，想要得到所有 的 表格。

2.思路：

很显然，可以轻松地求出使用所有物品装满容积 j 的方案数

表示使用前 i 个物品的容积为 j 的背包方案数

令表示不使用第 i 个物品的容积为 j 的背包方案数

· 1.当 的时候， 必然会包含选取了第 i 个物品所构成的一些方案，且在这些情况中，第 i 个物品必然只存在一个。那么，在$f[i][j] g[i][j-v[i]]$(不选i装满容积j-v[i])的状态下再拿了一个 i 构成的。

· 2.当的时候， 中本来就不包含选取 i 这个物品的情况所以直接就是 。

转移方程为： 最后加上滚动数组优化就好了

3.代码：

#include <iostream>
#include <cstdio>
using namespace std;
const int MAXN=3e3+7;
int f[MAXN],g[MAXN],v[MAXN];
template <typename _TP>
inline void qread(_TP &X){
    char ch=0;int w;X=0;
    while(!isdigit(ch)){w=ch=='-';ch=getchar();}
    while(isdigit(ch)){X=(X<<1)+(X<<3)+(ch^48);ch=getchar();}
    X=w?-X:X;
}
int main(){
    int n,m;
    qread(n);qread(m);
    for(int i=1;i<=n;i++){
        qread(v[i]);
    }
    f[0]=1;g[0]=1;
    for(int i=1;i<=n;i++){
        for(int j=m;j>=v[i];j--){
            f[j]=(f[j]+f[j-v[i]])%10;
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(j>=v[i])g[j]=(f[j]-g[j-v[i]]+10)%10;
            else g[j]=f[j];
            cout<<g[j];
        }
        cout<<"\n";
    }
    return 0;
} 

1.题意

地址:https://vjudge.net/problem/Kattis-incrementalinduction The Nordic Collegiate Pong Championship (NCPC) is an insanely competive tournament where every contestant plays exactly one game of Pong against every other contestant. The last game of the tournament just finished, so only one item now remains on the programme: the traditional diploma ceremony, where all this year’s participants get inducted into the NCPC Hall of Fame. According to the ancient customs, contestants who have not been inducted into the Hall of Fame yet (the pathetic nobodies) must stay on the left side of the stage, whereas contestants who have been inducted (the awesome legends) must be on the right side of the stage. Then, when a contestant is receiving their diploma, they will symbolically walk from the left to the right side of the stage and thus become an awesome legend. Only one contestant is inducted into the Hall of Fame at a time, and every contestant starts on the left side initially.

The NCPC Head of Jury believes it reflects badly on her if too many of the awesome legends on the right have lost matches against pathetic nobodies on the left, but she quickly realizes that it might be impossible to avoid this at every point in time during the diploma ceremony. However, she certainly wants to keep such atrocities at a minimum. Specifically, she wants to find the smallest number k for which there exists an order of handing out diplomas to the contestants, such that at no point there were more than k games played where an awesome legend lost against a pathetic nobody.

大致意思是：有n（n<=5000）个人需要去领奖，已经领奖的人就会变成大师，没有领奖的人就是菜鸡。每两人之间都会有对应的强弱关系。每当有一个人要去领奖时，对于每一对菜鸡和大师（场上所有人组成的关系而不是当前领奖者和所有大师组成的关系），k为当前情况下菜鸡战胜大师的对数。要求你求出一个合适的领奖顺序，使得k最小。输出最小的k值。

输入输出阅读原题

2.解法

很显然，我们应该让实力更强的人先去领奖。

在这个原则下，很显然的我们需要的时间统计当前所有的菜鸡打败大师的数量，总的时间复杂度就是,显然会TLE。对于每一对强弱关系，比如i强于j，则i向j连一条边。对于每个点的出度排序（入度也可，不过后面就要反着了）。

对于一个状态，它的k值就是noobs集合到masters集合的边的总数

因为每两个人之间都会有强弱关系，所以一这张图是一张完全图。所有所以两个集合之间的边数等于masters集合的出度数-master集合内部的所有边的数量，即为上式。 o(n)求解即可

3.代码

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 5e3+7;
int a[MAXN][MAXN],vis[MAXN];
struct node{
    int v,num;
}d[MAXN];
inline bool cmp(const node a,const node b){
    return a.v<b.v;
}
inline int Max(const int a,const int b){
    return a>b?a:b;
}
int main(){
    int n;
    scanf("%d",&n);getchar();
    for(int i=1;i<=n;i++){
        d[i].num=i;
    }
    for(int i=2;i<=n;i++){
        for(int j=1;j<i;j++){
            a[i][j]=getchar()-'0';
            a[j][i]=a[i][j]^1;
            if(a[i][j])d[i].v++;
            else d[j].v++;
        }
        getchar();
    }
    sort(d+1,d+n+1,cmp);
    int ans=0,res=0;
    for(int i=1;i<=n;i++){
        //vis[d[i].num]=1;
        // for(int j=1;j<=n;j++){
        //     if(i == j) continue;
        //     if(a[d[i].num][d[j].num] && !vis[d[j].num])res++;
        //     else if(a[d[j].num][d[i].num] && vis[d[j].num])res--;   
        // }
        //另外n^2的方法是反着统计的，图上的更好理解
        res+=d[i].v;
        ans=Max(ans,res-(i*(i-1))/2); //有向完全图，所以右边内部的边数=(i*(i-1))/2
    }
    cout<<ans;
    return 0;
}

1.关于欧拉筛

用途：线性的求区间[1,n]的所有质数

事实上，优化以后的埃氏筛已经很优秀了，一般情况下，很难通过时间复杂度区分欧拉筛和埃氏筛。

所以我们为什么需要欧拉筛

• 欧拉筛可以完成很多计数，比如欧拉函数
• 欧拉筛比较高级且常数略小一些

2.原理和过程

过程：

欧拉筛的主要思想是，用已知的质数筛掉这个质数的倍数。且需要保证对于任意一个合数，它会且只会它的最小因数筛掉

所以我们只需要枚举i = 2~n（主意1不是质数)在这个过程中维护已经发现的所有质数的集合。然后筛掉这些质数的i倍。一旦发现某个质数是i的因数，则不去筛所有比 大的质数的i倍 即：

if(!(i%prime[j]))break;

正确性证明：

% , 那么:

1.一定是i的最小质因数。因为是质数且，如果i还有比更小的因子，由于p数组是有序的，所以会在更靠前的位置被枚举到。为了满足对于任意一个合数，它会且只会它的最小因数筛掉，所以小于等于的质数都可以被使用。

2. i 一定是的因数。对于所有大于的质数，很显然不是的最小的因子，因为i里面一定有比更小的因子。为了满足对于任意一个合数，它会且只会它的最小因数筛掉，所以不使用所有大于等于的质数。

3.代码

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int MAXN = 1e8+7;
bool isprime[MAXN];
int prime[MAXN];
template <typename _TP>
inline _TP read(_TP &X){
    char ch=0;int w;X=0;
    while(!isdigit(ch)){w=ch=='-';ch=getchar();}
    while(isdigit(ch)){X=(X<<1)+(X<<3)+(ch^48);ch=getchar();}
    X=w?-X:X;
    return X;
}
int main(){
    int n,x,t;
    read(n);read(t);
    memset(isprime,1,sizeof(isprime));
    isprime[1]=0;
    int cnt=0;
    for(int i=2;i<=n;i++){
        if(isprime[i])prime[++cnt]=i;
        for(int j=1;j<=cnt && i*prime[j]<=n;j++){
            isprime[i*prime[j]]=false;
            if(!(i%prime[j]))break;
        }
    }
    for(int i=1;i<=t;i++){
        read(x);
        cout<<prime[x]<<'\n';
    }
    return 0;
}

1.题意：

地址:https://vjudge.net/problem/CodeForces-106E The Galaxy contains n planets, there are many different living creatures inhabiting each planet. And each creature can get into troubles! Space rescuers know it perfectly well and they are always ready to help anyone who really needs help. All you need to do is call for them.
Now the space rescuers plan to build the largest in the history of the Galaxy rescue station; however, the rescue station’s location is yet to be determined. As some cases are real emergencies, the rescuers want to find such a point in the Galaxy from which it would be possible to get to the remotest planet in the minimum possible time. In other words, the rescuers need such point in the space that the distance between it and the planet remotest from it was minimal (if we compare this point with all other possible points in the space). Unfortunately, the rescuers can’t sole this problem.
As the planets are quite remote from each other, they can be considered as points in Euclidean three-dimensional space. The distance between points () and () can be calculated by the formula . The rescue station can be positioned in any point in the space. It can also coincide with some planet.
Galaxy is in danger! Save the space rescuers and find the required point for them.

Input

The first line of the input file contains integer n — the number of planets (1 ≤ N ≤ 100). Each of the following n lines contains information about the planets. The i-th line contains three integers — the coordinates of the i-th planet ($ -10^{4 ≤ x_i, y_i, z_i ≤ 10}4, 1 ≤ i ≤ n$). No two planets coincide.

Output

Print on the first line of the output file three space-separated real numbers — the coordinates for the future base. If there are several solutions, you are allowed to print any of them. The answer will be accepted if the distance from this point to the remotest planet will differ from the juries’ variant in no more than in absolute or relative value.

2.思路：

本文提供两种做法，但只有一种做法写了程序并AC

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int MAXN = 1e2+7;
const double EPS = 1e-8;
template <typename _TP>
inline _TP read(_TP &X){
    char ch=0;int w;X=0;
    while(!isdigit(ch)){w=ch=='-';ch=getchar();}
    while(isdigit(ch)){X=(X<<1)+(X<<3)+(ch^48);ch=getchar();}
    X=w?-X:X;
    return X;
}
struct Point{
    int x,y,z;
}v[MAXN];
int main(){
    double x=0,y=0,z=0,T=1;
    int n,minPos;
    read(n);
    for(int i=1;i<=n;i++){
        Point tmp;
        read(tmp.x);read(tmp.y);read(tmp.z);
        v[i]=tmp;
        x+=tmp.x;y+=tmp.y;z+=tmp.z;
    }
    x/=n;y/=n;z/=n; //初始位置在重心 较优
    while(T > EPS){
        double maxx = -1;
        minPos = -1;
        for(int i=1;i<=n;i++){
            double t = (x-v[i].x)*(x-v[i].x)+(y-v[i].y)*(y-v[i].y)+(z-v[i].z)*(z-v[i].z);
            if(t > maxx){
                maxx = t;
                minPos = i;
            }
        }
        T *= 0.999;
        x+=T*(v[minPos].x-x);
        y+=T*(v[minPos].y-y);
        z+=T*(v[minPos].z-z);
    }
    printf("%.10f %.10f %.10f",x,y,z);
    return 0;
}

0.本文一切叙述前提为使用 Markdown PDF 插件导出PDF

1.导出时代码块自动换页与换行错误

如果使用 Markdown Preview Enhanced 插件进行预览，并从预览页面右键导出PDF的话，就有可能遇到代码块换页的问题和换行错误问题。

解决方法为：卸载 Markdown Preview Enhanced ，安装 Markdown All in One 然后在markdown源码页面右键导出PDF。并且，在 Markdown Preview Enhanced 提供的预览中，渲染出的换行和导出后的换行一致。

2.使用上述方法导出的PDF不渲染数学公式

找到如下路径(username为你的username)

C://Users/<username>/.vscode/extensions/yzane.markdown-pdf-1.4.1/template/template.html

在文件末尾添加(注意要写在body里面)

<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<script type="text/x-mathjax-config"> MathJax.Hub.Config({ tex2jax: {inlineMath: [['$', '$']]}, messageStyle: "none" });</script>

效果如下：

<!DOCTYPE html>
<html>
<head>
<title>{{{title}}}</title>
<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
{{{style}}}
{{{mermaid}}}
</head>
<body>
  <script>
    mermaid.initialize({
      startOnLoad: true,
      theme: document.body.classList.contains('vscode-dark') || document.body.classList.contains('vscode-high-contrast')
          ? 'dark'
          : 'default'
    });
  </script>
{{{content}}}
</body>
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<script type="text/x-mathjax-config"> MathJax.Hub.Config({ tex2jax: {inlineMath: [['$', '$']]}, messageStyle: "none" });</script>
</html>

1.前言：

场上这题证了三个小时没有证出来。所以以后有些题不证出来也要先找找规律出了。否则过于影响节奏。

2.题意：

地址：https://vjudge.net/problem/CodeForces-1514C

Now you get Baby Ehab’s first words: “Given an integer n, find the longest subsequence of 1,2,…,n−1 whose product is 11 modulo n.” Please solve the problem.

A sequence bb is a subsequence of an array aa if bb can be obtained from aa by deleting some (possibly all) elements. The product of an empty subsequence is equal to 11.

Input

The only line contains the integer .

Output

The first line should contain a single integer, the length of the longest subsequence.

The second line should contain the elements of the subsequence, in increasing order.

If there are multiple solutions, you can print any.

2.解法：

首先，我们对于给定的这 n-1 个数，只选取与 n 互质的数作为答案中出现的数。

然后，我们将这n-1个数中与n互质的数乘起来（对n取模）最后会得到一个数m，如果m=1，那么答案就是所有与n互质的数，如果m!=1，那么m一定是出现在 1到n-1的所有与n互质的数中。那么我们只需要在答案中删掉m这个数即可。

3.证明：

很显然，若i和n不互质，那么i的某个因数p（p!=1）一定是n的因数，那么如果i在答案中，那么所求答案序列的乘积中一定有p这个因数。根据 % 得到， 所以答案中必然不会出现与n不互质的数。

那么，问题的关键就在于，如何确定当的时候，m%n必然出现在1到n-1中与n互质的数中。很显然，因为m是所有小于n的与n互质的数的乘积，那么m中必然不含有n的因数（除了1）,那么一定与n互质。且一定小于n（因为模过了）。因为小于n的所有与n互质的数现在都在答案序列里，且n%m也是一个比n小的与n互质的数，那么n%m一定属于答案序列。

4.代码：

#include <iostream>
#include <cstdio>
using namespace std;
const int MAXN = 1e5+7;
int ans[MAXN];
template <typename _TP>
inline _TP read(_TP &X){
    char ch=0;int w;X=0;
    while(!isdigit(ch)){w=ch=='-';ch=getchar();}
    while(isdigit(ch)){X=(X<<1)+(X<<3)+(ch^48);ch=getchar();}
    X=w?-X:X;
    return X;
}
long long gcd(long long a,long long b){
    while(b){a%=b;a^=b;b^=a;a^=b;}
    return a;
}
int main(){
    long long n,res=1,cnt=0;
    read(n);
    for(int i=1;i<=n;i++){
        if(gcd(i,n) == 1){
            ans[++cnt]=i;
            res*=i;
            res%=n;
        }
    }
    if(res!=1){
        cout<<cnt-1<<'\n';
    }
    else {
        cout<<cnt<<'\n';
    }
    for(int i=1;i<=cnt;i++){
        if(ans[i]!=res || res==1){
            cout<<ans[i]<<' ';
        }
    }
    return 0;
}

1.前言：

CSP2019的前一天，早起到了学校。今天是高三二诊的第一天，恰好CSP和二诊冲掉了，不得已请了假。本来高三是不打算停课的，借此机会重温了一下子机房停课的快乐生活。停一天也是停嘛。

到了学校发现教练还没到，可能是我太久没有机房停课的生活，忘记了机房的生物钟了。一群人在实验楼连廊里等教练。等到大约八点半教练终于来上班了。（中间还被级部主任误以为是逃考试的学生……

看完了教练发的一套题，感觉挺简单的，做完了还没到中午放学，扭头看旁边同学在干什么，发现我的两个同学(均为高三)在研究一道题。(主角出场

2.题目大意

3.题解

首先，这道题是绝世好题。

我记得之前做题的时候见到一道题 P3396 哈希冲突 题解里说这道题是一篇省选论文里的，论文说：根号算法，不只是分块。(这也是一道绝世好题)

那么我也要说，今天的这道题 射击 是：枚举算法，不只是暴力。 这道题第一眼看来没什么思路，首先写搜索，大力剪枝之后最多只能拿到40分 搜索的复杂度是O(n^4)，妥妥的TLE那怎么办呢？ 先上代码：

  #include <iostream>
  #include <cstdio>
  using namespace std;
  long long a[1e6+7],ans;
  template <typename _TP>
  inline void read(_TP &X){
      char ch;int w;X=0;
      while(!isdigit(ch)){w=ch=='-';ch=getchar();}
      while(isdigit(ch)){X=(X<<1)+(X<<3)+(ch^48);ch=getchar();}
      X=w?-X:X;
  }
  int main(){
      int n,m;
      read(n);read(m);
      for(int i=1;i<=n;i++){
          read(a[i]);
      }
      int k=0;
      for(int i=1;i<=n;i++){
          for(int j=1;j<=1;j++){
              ++k;
              a[n+k]=a[i]+a[j];
          }
      }
      sort(a+1,a+n+k+1);
      i=1,j=n+k;
      while(i<=j){
          if(a[i]+a[j]<=m){
              if(a[i]+a[j]>ans)ans=a[i]+a[j];
              ++i;
          }
          else --j;
      }
      cout<<ans;
      return 0;
  }

这就是完整的代码了，什么意思呢？
考虑这样一个问题，我们可以把过程看成两个取两次而不是一个取四次
这里实际上使用了分别枚举的技巧，也就是说，先对前两次进行O(n^2)的枚举 ，记录状态，然后再对后两次取进行O(n^2)的枚举，记录状态。但实际上这两次枚举的结果是一模一样的，所以枚举一次就好了。
最后再对于前两次的结果进行一次O(n^2)的枚举。答案就有了。
这样看起来整体的复杂度是O(n^{2)的，但是，最后一次枚举的时候实际上状态数量是O(n}2)的.其实最后一次的枚举复杂度是O（n^4）的。所以说其实复杂度并没有优化。
枚举的代码是这样的：

    for(int i=1;i<=n;i++){
        for(int j=1;j<=1;j++){
            ++k;
            a[n+k]=a[i]+a[j];
        }
    }

但是
进行了前两次枚举就可以用一种类似贪心的方法进行处理了，也就是

    sort(a+1,a+n+k+1);
        i=1,j=n+k;
        while(i<=j){
            if(a[i]+a[j]<=m){
                if(a[i]+a[j]>ans)ans=a[i]+a[j];
                ++i;
            }
            else --j;
        }

这样，最后一次的贪心是O(n^2)的。