AtCoder ABC165

先吐槽一下题面锅了这回事，再吐槽下出题人英语水平…

A

给定三个数$a,b,n$，问$[a,b]$里面有没有$n$的倍数
如果$a,b$里面有一个是显然就是
剩下的看$\lfloor \frac{a}{n}\rfloor <\lfloor \frac{b}{n}\rfloor$就可以

int n,a,b;

int main()
{
    read(n),read(a),read(b);
    if(a%n==0||b%n==0)return puts("OK"),0;
    int t1=a/n,t2=b/n;
    if(t1<t2)puts("OK");
    else puts("NG");
    return 0;
}

B

最开始你有$100$块钱，每年获得$1\%$的利息，可以利滚利，问多少年后的钱$\ge X,X\le 10^{18}$
数据范围看上去非常大，但是我们观察一下第二个样例，在$X=10^{18}$的时候，只需要$3760$次，所以直接暴力就可以
为什么呢？我们发现随着时间的推移，他每年获得的钱就越多，所以就瞎搞搞就可以

# define int long long
int n;
int x=100,t;

signed main()
{
    read(n);
    while(x<n){
        x+=x/100;
        t++;
    }
    printf("%lld\n",t);
    return 0;
}

C

让你构造长度为$n$，每个数不超过$m$的一个递增数列，让$\sum d_i(A_{b_i}-A_{a_i}=C_i)$最大
好像还是很奇怪
但是我们看他是一个递增数列
也就是说根据插板法原则，最差的爆搜的复杂度是$C_{n+m}^{n}q$左右，显然可以通过这道题
所以这道题又是一个爆搜

int n,m,q;
int a[N],b[N],c[N],d[N];
int val[N];
int ans;

void dfs(int u,int last){
    if(u==n+1){
        int res=0;
        Rep(i,1,q)if(val[b[i]]-val[a[i]]==c[i])res+=d[i];
        ans=max(ans,res);
        return;
    }
    Rep(i,last,m)val[u]=i,dfs(u+1,i);
}

int main()
{
    read(n),read(m),read(q);
    Rep(i,1,q)read(a[i]),read(b[i]),read(c[i]),read(d[i]);
    dfs(1,1);
    printf("%d\n",ans);
    return 0;
}

D

对于给定$a,b,n$，试求$0\le x\le n$，使得$\lfloor \frac{ax}{b}\rfloor -a\lfloor \frac{x}{b}\rfloor$最大，输出这个最大值

显然，这个值是$b$个一循环的，也就是说我们只需要考虑所有$[0,b)$范围内的就可以了，那么显然取$x=b-1$的时候最优，但是因为有一个$\le n$的限制，所以我们取x=min⁡{b−1,n}x=\min\{b-1,n\}x=min{b−1,n}，带入求值即可

# define int long long

int a,b,n;

signed main()
{
    read(a),read(b),read(n);
    int t=min(b-1,n);
    printf("%lld\n",a*t/b-t/b*a);
    return 0;
}

E

没看懂

F

树上最长上升子序列板子题
这种树上的问题就是考虑做完子树之后把之前对答案的影响撤销掉嘛
我们用$f_i$表示以$i$为结尾的最长上升子序列的长度，那么可以列出一个转移方程
fi=max⁡{fj}+1,i∈subtree(j),aj<aif_i=\max\{f_j\}+1,i\in subtree(j),a_j<a_ifi​=max{fj​}+1,i∈subtree(j),aj​<ai​
显然$n^2$做法是不行的，那么考虑$\log$的做法，也就是树状数组或者贪心的做法
树状数组应该是不行的，因为我们要把之前的给撤掉，但是权值线段树大概好像可以（单点赋值，区间取max），但是线段树太长了啊，所以我们写二分的做法

我们用$g_i$表示长度$i$的最长上升子序列结尾的数最小是多少，那么显然$g$是单调不降的，可以二分
然后利用$a_i$去更新相应的$g$上面的位置就可以了
我们还需要记录一个原来的最小值，当访问完全部子树之后，再拿原来的最小值去撤掉这个点的贡献

具体看代码，记得离散化

# define int long long

int n;
int a[N],b[N],sz;
int head[N],cnt;
int f[N];
int ans;
int d[N];

struct Edge{
    int to,next;
}e[N<<1];

void add(int x,int y){
    e[++cnt]=(Edge){y,head[x]},head[x]=cnt;
}

void dfs(int u,int fa)
{
    int tmp=lower_bound(d,d+n,a[u])-d;
    f[u]=tmp+1;
    f[u]=max(f[u],f[fa]);
    int t=d[tmp];
    d[tmp]=a[u];
    RepG(i,u){
        int v=e[i].to;
        if(v==fa)continue;
        dfs(v,u);
    }
    d[tmp]=t;
}

signed main()
{
    memset(d,0x3f,sizeof(d));
    memset(head,-1,sizeof(head));
    read(n);
    Rep(i,1,n)read(a[i]),b[i]=a[i];
    sort(b+1,b+n+1);
    sz=unique(b+1,b+n+1)-b-1;
    Rep(i,1,n)a[i]=lower_bound(b+1,b+sz+1,a[i])-b;
    Rep(i,1,n-1){
        int x,y;
        read(x),read(y);
        add(x,y),add(y,x);
    }
    dfs(1,0);
    Rep(i,1,n)printf("%lld\n",f[i]);
    return 0;
}