0+0+0=0。还是太菜，看不出题型。

Masodik

你要从 (0,0) 点走到 (n,m)，每次只能往 x 轴或者 y 轴正方向移动一个单位距离。从 (i,j) 移动到 (i,j+1) 的代价为 r_i,从 (i,j) 移动到 (i+1,j) 的代价为 c_j。

求最小代价。

对于 100%的数据，n,m ≤ 10⁵。

题解

凸包的运用……我看不出来还算正常。

考虑从 \((x_1,y_1)\) 走到 \((x_2,y_2)\)，只能先走行再走列或者先走列再走行。

1. 先走行再走列，代价为
   \[ r_{x_1}(y_2-y_1)+c_{y_2}(x_2-x_1) \]

2. 先走列再走行，代价为
   \[ c_{y_1}(x_2-x_1)+r_{x_2}(y_2-y_1) \]

对这两种走法进行套路化比较
\[ r_{x_1}(y_2-y_1)+c_{y_2}(x_2-x_1)<c_{y_1}(x_2-x_1)+r_{x_2}(y_2-y_1)\\Rightarrow~\frac{r_{x_2}-r_{x_1}}{x_2-x_1}>\frac{c_{y_2}-c_{y_1}}{y_2-y_1} \]
所以对行列分别维护凸包，双指针扫描，每次走斜率大的。

时间复杂度 \(O(n+m)\)。

#include<bits/stdc++.h>
using namespace std;
template<class T> T read(){
    T x=0,w=1;char c=getchar();
    for(;!isdigit(c);c=getchar())if(c=='-') w=-w;
    for(;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*w;
}
template<class T> T read(T&x){
    return x=read<T>();
}
#define co const
#define il inline
typedef long long LL;

co int N=100000+10;
int r[N],c[N];
int sr[N],tr,sc[N],tc;

void convex(int a[],int st[],int&top,int n){
    for(int i=0;i<=n;++i){
        while(top>=2&& (LL)(a[i]-a[st[top]])*(st[top]-st[top-1])<=(LL)(a[st[top]]-a[st[top-1]])*(i-st[top]) ) --top;
        st[++top]=i;
    }
}
int main(){
    freopen("masodik.in","r",stdin),freopen("masodik.out","w",stdout);
    int n=read<int>(),m=read<int>();
    for(int i=0;i<=n;++i) read(r[i]);
    for(int i=0;i<=m;++i) read(c[i]);
    convex(r,sr,tr,n),convex(c,sc,tc,m);
    LL ans=0;
    int i=1,j=1;
    while(i<tr&&j<tc){
        if( (LL)(r[sr[i+1]]-r[sr[i]])*(sc[j+1]-sc[j])>=(LL)(c[sc[j+1]]-c[sc[j]])*(sr[i+1]-sr[i]) )
            ans+=(LL)r[sr[i]]*(sc[j+1]-sc[j]),++j;
        else ans+=(LL)c[sc[j]]*(sr[i+1]-sr[i]),++i;
    }
    if(i==tr) ans+=(LL)r[n]*(m-sc[j]);
    else ans+=(LL)c[m]*(n-sr[i]);
    printf("%lld\n",ans);
    return 0;
}

Query on a sequence

给定一个长度为 n 的数列 P，满足 |Pi| ≤ 10⁹
求有多少对 (a,b,c,d)，满足下列约束：

1. 1 ≤ a ≤ b < c ≤ d ≤ n
2. b-a=d-c
3. c-b-1 等于恰好等于给定的 F，且 F>0
4. P_a+i=P_c+i 对于所有 i(0≤i≤b-a) 均成立

只要 (a,b,c,d) 中有任意一个参数不同，我们就认为是不同的。

n ≤ 10⁵

CH#15 秘密武器

被题目名字骗了，我竟然没有看出来这是字符串匹配……我该更新自己对字符集的认识。

枚举两段的长度 len 和第一段的起点 i，我们定义 L 为第一段与第二段的最长公共后缀，当 L>=len 的时候答案+1，而起点为 i+1 时 L 的大小仅仅取决于起点为 i 时 L 大小和 a[i+len] 与 a[i+2*len+F] 的相等关系：

• L[i+1] = L[i] + 1 (a[i+len]=a[i+2*len+F])
• L[i+1] = 0 (a[i+len]!=a[i+2*len+F])

这样相当于把原串右移 len+F 后得到的新串与原串的匹配

朴素地枚举 len 后扫描整个序列是 N² 的，我们考虑优化这个算法。

首先枚举两段的长度 len，然后我们在递推的时候可以发现，在长度为 len 时，我们没有必要一格一格的递推，而可以每次向右递推 len 格。这是因为我们把原串按照 len 分段，出现下面这种红色匹配是无意义的

我们不妨设第一段的末尾位置为 i，第二段的末尾位置为 j，设 frontL 表示 a[i+1]?a[i+len] 与 a[j+1]?a[j+len] 的最长公共前缀，设 backL 表示 a[i+1]?a[i+len] 与 a[j+1]?a[j+len] 的最长公共后缀，令 L 表示当前的最长公共后缀。

下面分两种情况考虑对于答案的贡献：

1. 如果 L>=len-1，ans+=frontL。
2. 反之，ans+=max{0,L+frontL-(len-1)}。

下面分两种情况考虑递推后的最长公共后缀 nL:

1. 如果 a[i+1]?a[i+len]与 a[j+1]?a[j+len]整段相同，nL=L+len。
2. 反之，nL=backL。

这样对于每个长度 len，需要递推 N/len 次，每次采用 hash+二分的方法 O(logN) 的计算最长公共前/后缀，总的复杂度为 O(N lnN logN)。

#include<bits/stdc++.h>
#include<tr1/unordered_map>
using namespace std;
template<class T> T read(){
    T x=0,w=1;char c=getchar();
    for(;!isdigit(c);c=getchar())if(c=='-') w=-w;
    for(;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*w;
}
template<class T> T read(T&x){
    return x=read<T>();
}
#define co const
#define il inline
typedef unsigned long long ULL;

co int N=100000+10;
co ULL B=131;
int n,a[N];
ULL hash[N],pb[N];

il ULL calc(int l,int r){ // hash[l,r]
    return hash[r]-hash[l-1]*pb[r-l+1];
}
int lcp(int x,int y){ // longest common prefix
    int l=0,r=min(n-x+1,n-y+1);
    while(l<r){
        int mid=(l+r+1)>>1;
        if(calc(x,x+mid-1)==calc(y,y+mid-1)) l=mid;
        else r=mid-1;
    }
    return l;
}
int lcs(int x,int y){ // longest common suffix
    int l=0,r=min(x,y);
    while(l<r){
        int mid=(l+r+1)>>1;
        if(calc(x-mid+1,x)==calc(y-mid+1,y)) l=mid;
        else r=mid-1;
    }
    return l;
}

int main(){
    freopen("count.in","r",stdin),freopen("count.out","w",stdout);
    read(n);int F=read<int>();
    pb[0]=1;
    for(int i=1;i<=n;++i) pb[i]=pb[i-1]*B;
    tr1::unordered_map<int,int> val;
    int idx=0;
    for(int i=1;i<=n;++i){
        if(!val.count(read(a[i]))) val[a[i]]=++idx;
        a[i]=val[a[i]],hash[i]=hash[i-1]*B+a[i];
    }
    ULL ans=0;
    for(int len=1;2*len+F<=n;++len){
        int L=0;
        for(int i=1;;){
            int lim=min(len,n-(i+len+F-1));
            if(!lim) break;
            int frontL=lcp(i,i+len+F),backL=lcs(i+lim-1,i+len+F+lim-1);
            frontL=min(frontL,lim),backL=min(backL,lim);
            if(L>=len-1) ans+=frontL;
            else ans+=max(0,L+frontL-(len-1));
            if(frontL==lim) L+=lim;
            else L=backL;
            i+=lim;
        }
    }
    printf("%llu\n",ans);
    return 0;
}

Number Theory

对于给定的 \(x,m,p\)（\(p\) 是质数），求一个可行的正整数 \(n\)，满足
\[ n^{2n}+n^{m} \equiv x \mod p \]

由于解不唯一，所以这题设有 Special Judge，支持检验高精度的 \(n\)。

\(p \leq 10^9+7\)，可以认为这些质数都很大且随机生成。

题解

原根的运用……我一 NOIP 考生不会往这边想啊。

这是不是一种新的做二次剩余的方法？

#include<bits/stdc++.h>
#include<tr1/unordered_map>
using namespace std;
template<class T> T read(){
    T x=0,w=1;char c=getchar();
    for(;!isdigit(c);c=getchar())if(c=='-') w=-w;
    for(;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*w;
}
template<class T> T read(T&x){
    return x=read<T>();
}
#define co const
#define il inline
#define int long long

#define gcd __gcd
void exgcd(int a,int b,int&x,int&y){
    if(!b) x=1,y=0;
    else exgcd(b,a%b,y,x),y-=a/b*x;
}
il int inv(int a,int mod){
    int x,y;
    exgcd(a,mod,x,y);
    return x<0?x+mod:x;
}
il int mul(int a,int b,int mod){
    int ans=0;
    for(;b;b>>=1,a=(a+a)%mod)
        if(b&1) ans=(ans+a)%mod;
    return ans;
}
il int pow(int a,int b,int mod){
    int ans=1;
    for(;b;b>>=1,a=a*a%mod)
        if(b&1) ans=ans*a%mod;
    return ans;
}
int bsgs(int a,int b,int mod){
    tr1::unordered_map<int,int> H;
    int blo=ceil(sqrt(mod));
    for(int i=1;i<=blo;++i) H[pow(a,i,mod)*b%mod]=i;
    a=pow(a,blo,mod);
    for(int i=1,c=a;i<=(mod+blo-1)/blo;++i,c=c*a%mod)
        if(H[c]) return i*blo-H[c];
    return -1;
}
signed main(){
    freopen("theory.in","r",stdin),freopen("theory.out","w",stdout);
    int sum=read<int>(),m=read<int>(),p=read<int>();
    for(int g=2;;++g){ // enumerate the primitive root
        int k=bsgs(g,(sum+p-pow(g,m,p))%p,p); // g^k=sum-g^m (mod p)
        if(k==-1||k&1) continue;
        int M=p*(p-1);
        printf("%lld\n",mul(g*(p-1),inv(p-1,p),M)+k/2*p%M); // p^{-1}=1 (mod p-1)
        break;
    }
    return 0;
}

test20190901 NOI2019 模拟赛

原文：https://www.cnblogs.com/autoint/p/test20190901.html