The Preliminary Contest for ICPC China Nanchang National Invitational and International Silk-Road Programming Contest

打网络赛

比赛前的准备工作要做好

确保 c++/java/python的编译器能用

打好模板，放在桌面

A. PERFECT NUMBER PROBLEM

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <iostream>
using namespace std;

#define ll long long

const int maxn=1e8+10;
const int inf=1e9;
const double eps=1e-8;

int sum[maxn];

int main()
{
    int n=100000000,i,j;
    for (i=1;i<n;i++)
        for (j=i;j<n;j+=i)
            sum[j]+=i;
    for (i=1;i<n;i++)
        if (sum[i]==i+i)
            printf("%d ",i);
    return 0;
}
/*
6 28 496 8128 33550336
Process returned 0 (0x0)   execution time : 24.646 s
*/

较差的打表方法

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <iostream>
using namespace std;

#define ll long long

const int maxn=1e4+10;
const int inf=1e9;
const double eps=1e-8;



int main()
{
    ///我相信很大一部分同学是网上找答案的，这不好
//    printf("6
28
496
8128
33550336");
    ll sum,i,j,k;
    for (i=1;i<=1000000000;i++)
    {
        sum=0;
        k=sqrt(i);
        for (j=1;j<=k;j++)
            if (i%j==0)
                sum+=j+i/j;
        if (k*k==i)
            sum-=i;
        sum-=i;
        if (sum==i)
            printf("%d ",i);
        if (i%1000000==0)
            printf("i=%d
",i);
    }
    return 0;
}
/*
6 28 496 8128 33550336
18 min
*/

C. Angry FFF Party

fib(x) 逐渐变得很大

而fib(fib(x))更是如此，

感觉可以打表

于是用python打表验证一下

import math

​

a=1/math.sqrt(5)

b=(1+math.sqrt(5))/2

c=(1-math.sqrt(5))/2

a

0.4472135954999579

a

for n in range(1,16):

    print(n)

    x=a*(pow(b,n) - pow(c,n))

    x=round(x)

    print(x)

​

    y=a*(pow(b,x) - pow(c,x))

    print(y)

    print()

1
1
1.0

2
1
1.0

3
2
1.0

4
3
2.0

5
5
5.000000000000001

6
8
21.000000000000004

7
13
233.00000000000006

8
21
10946.000000000007

9
34
5702887.0000000065

10
55
139583862445.00024

11
89
1.7799794160047194e+18

12
144
5.555654042242954e+29

13
233
2.2112364063039317e+48

14
377
2.746979206949977e+78

15
610
1.3582369791278544e+127

开始用java写 BigInteger

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    static class mat {
        BigInteger [][]a=new BigInteger[2][2];
        mat() {
            a[0][0]=a[0][1]=a[1][0]=a[1][1]=BigInteger.ZERO;
        }
        static mat mul(mat a,mat b) {
            mat c=new mat();
            for (int k=0;k<2;k++)
                for (int i=0;i<2;i++)
                    for (int j=0;j<2;j++)
                        c.a[i][j]=c.a[i][j].add(a.a[i][k].multiply(b.a[k][j]));
            return c;
        }
        void print() {
            for (int i=0;i<2;i++) {
                for (int j=0;j<2;j++)
                    System.out.print(a[i][j]+" ");
                System.out.println();
            }
            System.out.println();
        }
    }
    
    static BigInteger _pow(int n) {
        mat a=new mat();
        mat b=new mat();
        a.a[0][0]=BigInteger.ONE;
        a.a[0][1]=BigInteger.ZERO;
        a.a[1][0]=BigInteger.ZERO;
        a.a[1][1]=BigInteger.ONE;
        
        b.a[0][0]=BigInteger.ONE;
        b.a[0][1]=BigInteger.ONE;
        b.a[1][0]=BigInteger.ONE;
        b.a[1][1]=BigInteger.ZERO;

        while (n>0) {
            if (n%2==1)
                a=mat.mul(a,b);
            b=mat.mul(b,b);
//            b.print();
            n>>=1;
        }
        return a.a[1][0];
    }
    
    public static void main(String[] args) throws Exception {
        
        int i,len=100000;//10
        int []a=new int[100];
        BigInteger []b=new BigInteger[100];
        StringBuffer s=new StringBuffer("1");
        for (i=0;i<len;i++)
            s=s.append("0");
        String ss=new String(s);
        BigInteger maxb=new BigInteger(ss);
//        System.out.println(maxb);
        
//        _pow(10);
        
        a[1]=a[2]=1;
        mat ma = new mat();
        for (i=1;i<100;i++) {
            if (i<3)
                a[i]=1;
            else
                a[i]=a[i-1]+a[i-2];
//            System.out.println(a[i]);
            b[i]=_pow(a[i]);
//            if (i<10)
//                System.out.println(b[i]);
            if (b[i].compareTo(maxb)>=0)
                break;
        }
//        System.out.println("i="+i);
        int maxg=i;
        
        Scanner in=new Scanner(System.in);
        int t=in.nextInt();
        BigInteger m;
        
        int []num=new int[100];
            int g=0;
            BigInteger[] bb=new BigInteger[11];
            for (i=0;i<=10;i++)
                bb[i]=new BigInteger(Integer.toString(i));
            String []pr=new String[11];
            
        /*
        1 1 1 2 5 21
        */
            pr[1]="1";
            pr[2]="1 2";
            pr[3]="1 2 3";
            pr[4]="1 2 4";
            pr[5]="1 2 3 4";
            for (i=6;i<=10;i++)
                pr[i]=pr[i-5]+" 5";
            
        while (t-->0) {
            m=in.nextBigInteger();
            
            g=0;
            if (m.compareTo(bb[10])>0) {
                for (i=maxg;i>5;i--)
                    if (m.compareTo(b[i])>=0) {
                        m=m.subtract(b[i]);
                        g=g+1;
                        num[g]=i;
                    }
            }
            if (m.compareTo(bb[10])>0)
                System.out.println(-1);
            else {                
                for (i=1;i<=10;i++)
                    if (m.compareTo(bb[i])==0)
                        System.out.print(pr[i]);
                if (m.compareTo(bb[0])!=0 && g!=0)
                    System.out.print(" ");
                if (g==0)
                    System.out.println();
                for (i=g;i>=1;i--) {
                    System.out.print(num[i]);
                    if (i==1)
                        System.out.println();
                    else
                        System.out.print(" ");
                }
            }
        }
    }
}
/*
1 1 1 2 5 21

1
1
1
2
5
21
233
10946
5702887

100
1-10
11
21
27
*/

H. Coloring Game

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <iostream>
using namespace std;

#define ll long long

const int maxn=1e4+10;
const int inf=1e9;
const double eps=1e-8;
const ll mod=1e9+7;

ll mul(ll a,ll b)
{
    ll y=1;
    while (b)
    {
        if (b&1)
            y=y*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return y;
}

int main()
{
    int n;
    scanf("%d",&n);
    if (n==1)
        printf("1");
    else
        printf("%lld",mul(3,n-2)*4%mod);
    return 0;
}
/*
1000000000
*/

K. MORE XOR

找规律

推公式较为复杂，据说用插板法

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <iostream>
using namespace std;

#define ll long long

const int maxn=1e5+10;
const int inf=1e9;
const double eps=1e-8;

int f[4][maxn],a[maxn];

int main()
{
//    printf("%d",1^2^5^6^9^10);
    int T,n,q,i,j,k,x,y,s,t,v;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d",&n);
        for (i=1;i<=n;i++)
            scanf("%d",&a[i]);

        for (k=0;k<4;k++)
            for (i=(k==0)?4:k,j=1;i<=n;i+=4,j++)
                f[k][j]=f[k][j-1]^a[i];

        scanf("%d",&q);
        while (q--)
        {
            scanf("%d%d",&i,&j);
            y=(j-i+1)%4;
            if (y==1)
            {
                ///i,i+4,i+8 ...
                x=i%4;
                s=(i+3)/4;
                t=s+(j-i)/4;
                printf("%d
",f[x][t]^f[x][s-1]);
            }
            else if (y==2)
            {
                x=i%4;
                s=(i+3)/4;
                t=s+(j-i)/4;
                v=f[x][t]^f[x][s-1];

                i++;
                x=i%4;
                s=(i+3)/4;
                t=s+(j-i)/4;
                printf("%d
",v^f[x][t]^f[x][s-1]);
            }
            else if (y==3)
            {
                i++;
                x=i%4;
                s=(i+3)/4;
                t=s+(j-i)/4;
                printf("%d
",f[x][t]^f[x][s-1]);
            }
            else
                printf("0
");
        }
    }
    return 0;
}
/*
1
10
1 2 3 4 5 6 7 8 9 10
100
1 7
*/

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <iostream>
using namespace std;

#define ll long long

const int maxn=1e4+10;
const int inf=1e9;
const double eps=1e-8;

int n=10;

struct node
{
    int a[30];
    node operator+(const node &y)
    {
        node z;
        for (int i=1;i<=n;i++)
            z.a[i]=a[i]+y.a[i];
        return z;
    }
}f[4][30][30];

int main()
{
    int i,j,k,l;
    int x=3;
    for (i=1;i<=n;i++)
        f[0][i][i].a[i]=1;
    for (l=1;l<=x;l++)
    {
//        for (i=1;i<n;i++)
//        {
//            f[l][i][i]=f[l-1][i][i];
//            for (j=i+1;j<=n;j++)
//                f[l][i][j]=f[l][i][j-1]+f[l-1][j][j];
//        }

        for (i=1;i<=n;i++)
            for (j=i;j<=n;j++)
            {
                if (i!=j)
                    f[l][i][j]=f[l][i][j-1];
                for (k=i;k<=j;k++)
                    f[l][i][j]=f[l][i][j]+f[l-1][k][j];
            }
    }
    int y=3;
    for (i=1;i<=n;i++)
    {
        for (j=1;j<=n;j++)
//            printf("%d%c",f[y][1][i].a[j],j==n?'
':' ');
            printf("%d%c",f[y][1][i].a[j] &1,j==n?'
':' ');
    }
    return 0;
}
/*
1 0 0 0 0 0 0 0 0 0
1 1 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 0 0
1 1 0 0 1 1 0 0 0 0
0 1 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 1 0
1 1 0 0 1 1 0 0 1 1

1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
1 1 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0
1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 0 0 0 0
0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0
1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0
0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
*/

M. Subsequence

序列自动机

非正统的写法：

1.从后往前，记录每一个字符最新出现的位置

2.贪心，找到第一个字符，在第一个字符位置之后找第二个字符，...

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <iostream>
using namespace std;

#define ll long long

const int maxn=1e5+10;
const int inf=1e9;
const double eps=1e-8;

int f[maxn][128],pre[maxn];
char s[maxn];

int main()
{
    int i,j,len,t;
    memset(pre,0xff,sizeof(pre));
    s[0]='a';
    scanf("%s",s+1);
    len=strlen(s+1);
    for (i=len;i>=0;i--)
    {
        for (j=0;j<128;j++)
            f[i][j]=pre[j];
        pre[s[i]]=i;
    }
    scanf("%d",&t);
    while (t--)
    {
        scanf("%s",s);
        len=strlen(s);
        j=f[0][s[0]];
        for (i=1;i<len;i++)
        {
            if (j==-1)
                break;
            j=f[j][s[i]];
        }
        if (j!=-1)
            printf("YES
");
        else
            printf("NO
");
    }
    return 0;
}
/*

*/

C. Angry FFF Party

数位dp

原来的数据是完全无用的，
只需要火柴棒总数保持一致，
只需要对于每一位，火柴棒加的次数完全一样

不用考虑前导0
+0 -> +9
-0  -> +5

w为数字的位数，y使用的火柴数
f[w][y] 的最大值
f[w][y]=max(f[w-1][y-g[i]]+i*10^(w-1))    i=0..9
w<10,y<w*7+2

-11..1 无法改变
f[1][3]=-1
f[p][p*2+1]=-11..1
其它时候不用减法(至少可以节省一根火柴，使负号变为加号)
这个不成立，在第一个数时(潜在加法)
预处理

对于当前的前x个数字，y为使用的火柴棒总数，以此最大的值
对于第x个数字，位数为w
a[x][y]=max(a[x-1][z]+f[w][z-y])
x<=50,y<=7*50+2*49=448
[49个加号，50个数]


易错点：
+/- 不能单独每一位，而要整体求

正确通过

2019-04-21 00:57

5ms

448kB

c++14

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <iostream>
using namespace std;

#define ll long long

const int maxn=1e4+10;
const int inf=1e9;
const double eps=1e-8;

/**
其实最多只有9位，
是小于10^9，没有等于

999999999+999999999+...
超过int
**/

int g[10]={6,2,5,5,4,5,6,3,7,6};
int f[12][100];
int mul[12];
ll a[51][500];
int fv[12];
int add[128];
char s[110];

int main()
{
    bool vis;
    int i,j,k,l,maxw,w,t,n,tot,sum,c;

//    printf("%d
",'+');///43
//    printf("%d
",'-');///45
    add[43]=2,add[45]=1;
    for (i=48;i<48+10;i++)
        add[i]=g[i-48];

    mul[1]=1;
    for (i=2;i<=9;i++)
        mul[i]=mul[i-1]*10;

    fv[1]=-1;
    for (i=2;i<=9;i++)
        fv[i]=fv[i-1]*10-1;

    memset(f,0x8f,sizeof(f));
    f[0][2]=0;///+
    for (i=1;i<=10;i++)
    {
        maxw=(i-1)*7+2;
        for (j=0;j<=maxw;j++)
            for (l=0;l<=9;l++)  ///或者只要用火柴数在一个数量时最大的数即可
                f[i][j+g[l]]=max(f[i][j+g[l]],f[i-1][j]+l*mul[i]);
    }

    scanf("%d",&t);
    while (t--)
    {
        memset(a,0x8f,sizeof(a));
        scanf("%d",&n);
        scanf("%s",s);
        tot=0;
        vis=0;
        sum=0;
        a[0][0]=0;
        i=0;
        c=0;
        for (w=0;w<=n;w++)
        {
            tot+=add[s[w]];
            if (s[w]=='+' || s[w]=='-' || w==n)
            {
                c++;
                maxw=i*7+2;
                for (j=0;j<=sum;j++)
                    for (k=0;k<=maxw;k++)
                        ///f[i][k](int memset)相比a[j](ll memset)小很多，减很多次，仍不会到达下界
                        a[c][j+k]=max(a[c][j+k],a[c-1][j]+f[i][k]); ///可以使用滚动数组

                if (vis)
                    for (j=0;j<=sum;j++)
                        a[c][j+2*i+1]=max(a[c][j+2*i+1],a[c-1][j]+fv[i]);

                sum+=maxw; ///当然也可以求出tot后再求
                vis=1;
                i=0;
                continue;
            }
            else
                i++;
        }
        printf("%lld
",a[c][tot+2]);  ///第一个加号是没有的
    }
    return 0;
}
/*
10
11
100000000+9
13
111-111111-11
20
100000000-99999999+1
36
10000000+12345+0+1+2+3+4+5+6+7+8+9

*/

I. Max answer

单调栈+线段树

单调栈
找到一个数左边/右边的第一个大于其的数
把数列出来，容易找到方法
7 8 9 5(则9 8 7 出栈并赋值)


线段树
[l,r]区间 数为d 包含d的最大区间
sum[query_max(d,r)] - sum[query_min(l,d-1)]

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <vector>
#include <bitset>
#include <algorithm>
#include <iostream>
using namespace std;
#define ll long long

const double eps=1e-8;
const int maxn=5e5+10;
const ll inf=1e18;


int a[maxn],lef[maxn],rig[maxn],st[maxn],maxnum[maxn<<2],minnum[maxn<<2];
ll sum[maxn];

void build(int ind,int l,int r)
{
    if (l==r)
        maxnum[ind]=minnum[ind]=l;
    else
    {
        int m=(l+r)>>1;
        build(ind<<1,l,m);
        build(ind<<1|1,m+1,r);
        if (sum[ maxnum[ind<<1] ] > sum[ maxnum[ind<<1|1] ])
            maxnum[ind]=maxnum[ind<<1];
        else
            maxnum[ind]=maxnum[ind<<1|1];

        if (sum[ minnum[ind<<1] ] < sum[ minnum[ind<<1|1] ])
            minnum[ind]=minnum[ind<<1];
        else
            minnum[ind]=minnum[ind<<1|1];
    }
}

int query_max(int ind,int l,int r,int x,int y)
{
    if (x>y)
        return 0;
    if (x<=l && r<=y)
        return maxnum[ind];
    int m=(l+r)>>1,b=-1;
    if (x<=m)
        b=query_max(ind<<1,l,m,x,y);
    if (m<y)
    {
        if (b==-1)
            return query_max(ind<<1|1,m+1,r,x,y);
        else
        {
            int c=query_max(ind<<1|1,m+1,r,x,y);
            if (sum[b]>sum[c])
                return b;
            return c;
        }
    }
    return b;   ///
}

int query_min(int ind,int l,int r,int x,int y)
{
    if (x>y)
        return 0;
    if (x<=l && r<=y)
        return minnum[ind];
    int m=(l+r)>>1,b=-1;
    if (x<=m)
        b=query_min(ind<<1,l,m,x,y);
    if (m<y)
    {
        if (b==-1)
            return query_min(ind<<1|1,m+1,r,x,y);
        else
        {
            int c=query_min(ind<<1|1,m+1,r,x,y);
            if (sum[b]<sum[c])
                return b;
            return c;
        }
    }
    return b;   ///
}

int main()
{
    int n,i,g;
    ll r;
    scanf("%d",&n);
    for (i=1;i<=n;i++)
        scanf("%d",&a[i]);

    g=0;
    for (i=1;i<=n;i++)
    {
        while (g>0 && a[st[g]]>a[i])
        {
            rig[st[g]]=i;
            g--;
        }
        st[++g]=i;
        sum[i]=sum[i-1]+a[i];
    }

    g=0;
    for (i=n;i>=1;i--)
    {
        while (g>0 && a[st[g]]>a[i])
        {
            lef[st[g]]=i;
            g--;
        }
        st[++g]=i;
    }

    build(1,1,n);
    r=-inf;
    for (i=1;i<=n;i++)
    {
        if (rig[i]==0)
            rig[i]=n+1;
        if (a[i]>=0)
            r=max(r,a[i]*(sum[rig[i]-1]-sum[lef[i]]));
        else
            r=max(r,a[i]*(sum[query_min(1,1,n,i,rig[i]-1)]-max(0ll,sum[query_max(1,1,n,lef[i]+1,i-1)])));///<
    }
    printf("%lld",r);
    return 0;
}
/*
5
-2 1 -3 -4 3

6
-1 -2 -3 -4 -5 -6

3
-1 -3 -2


1
-3
*/

J. Distance on the tree

1.树剖

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
using namespace std;
#define ll long long
const double eps=1e-8;
const int maxn=1e5+10;

///°´ÕձߵĴóСÅÅÐò
///树剖: 边 而不是 点

struct node
{
    int d;
    node *to;
}*e[maxn];

struct rec
{
    int u,v,w,num,mode;
    bool operator<(const rec &y) const
    {
        if (w==y.w)
            return mode<y.mode;
        return w<y.w;
    }
}b[maxn+maxn];

int sum[maxn];

int fa[maxn],dep[maxn],siz[maxn],son[maxn];
int id[maxn],top[maxn];
int n,num;
bool vis[maxn];
int tr[maxn<<2];

void dfs1(int d)
{
    int dd;
    node* p=e[d];
    vis[d]=1;
    siz[d]=1;
    while (p)
    {
        dd=p->d;
        if (!vis[dd])
        {
            fa[dd]=d;
            dep[dd]=dep[d]+1;
            dfs1(dd);
            siz[d]+=siz[dd];
            if (siz[dd]>siz[son[d]])
                son[d]=dd;
        }
        p=p->to;
    }
}

void dfs2(int d,int topd)
{
    id[d]=++num;
    top[d]=topd;
    if (son[d]!=0)
    {
        int dd;
        node *p;
        dfs2(son[d],topd);

        p=e[d];
        while (p)
        {
            dd=p->d;
            if (dd!=son[d] && dd!=fa[d])
                dfs2(dd,dd);
            p=p->to;
        }
    }
}

void update(int ind,int l,int r,int x)
{
    tr[ind]++;
    if (l==r)
        return;
    int m=(l+r)>>1;
    if (x<=m)
        update(ind<<1,l,m,x);
    else
        update(ind<<1|1,m+1,r,x);
}

int query(int ind,int l,int r,int x,int y)
{
    if (x<=l && r<=y)
        return tr[ind];
    int m=(l+r)>>1,sum=0;
    if (x<=m)
        sum+=query(ind<<1,l,m,x,y);
    if (m<y)
        sum+=query(ind<<1|1,m+1,r,x,y);
    return sum;
}

int cal(int x,int y)
{
    int sum=0;
    while (top[x]!=top[y])
    {
        if (dep[top[x]]<dep[top[y]])
            swap(x,y);
        sum+=query(1,1,n,id[top[x]],id[x]);
        x=fa[top[x]];
    }

    if (dep[x]<dep[y])
        swap(x,y);
    ///u,v not the same
    ///减去根节点
    return sum+query(1,1,n,id[y]+1,id[x]);
}

int main()
{
    node *p;
    int m,i,u,v;
    scanf("%d%d",&n,&m);
    for (i=1;i<n;i++)
    {
        scanf("%d%d%d",&b[i].u,&b[i].v,&b[i].w);
        b[i].num=i;
        b[i].mode=0;

        p=new node();
        p->d=b[i].v;
        p->to=e[b[i].u];
        e[b[i].u]=p;

        p=new node();
        p->d=b[i].u;
        p->to=e[b[i].v];
        e[b[i].v]=p;
    }
    for (i=n;i<n+m;i++)
    {
        scanf("%d%d%d",&b[i].u,&b[i].v,&b[i].w);
        b[i].num=i;
        b[i].mode=1;
    }
    sort(b+1,b+n+m);

    fa[1]=1;
    dfs1(1);

    dfs2(1,1);

    for (i=1;i<n+m;i++)
    {
        u=b[i].u;
        v=b[i].v;
        if (dep[u]<dep[v])
            swap(u,v);

        ///往距离远的点加值
        if (b[i].num<n)
            update(1,1,n,id[u]);
        else
            sum[b[i].num-n+1]=cal(u,v);
    }

    for (i=1;i<=m;i++)
        printf("%d
",sum[i]);
    return 0;
}

2.主席树

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
using namespace std;

#define ll long long
const double eps=1e-8;
const int maxn=1e5+10;
const int maxv=1e9;

///1-i中的所有数 1-fa(j) -> 1-j 链 主席树

struct node
{
    int d,len,num;
    node *to;
    node *opp;
    int c;
}*e[maxn],*point[maxn];

struct rec
{///any d,dd 经历两次 可以选择d中加入编号比其大的
    int l,r,sum;
}tr[maxn*50];

int sum[maxn],fa[maxn],be[maxn],num;
bool vis[maxn];

void build(int ind_old,int ind,int l,int r,int x)
{
    if (l==r)   ///single
    {
        tr[ind].sum=tr[ind_old].sum+1;
        return;
    }
    int m=(l+r)>>1;
    if (x<=m)
    {
        tr[ind].r=tr[ind_old].r;
        tr[ind].l=++num;
        build(tr[ind_old].l,tr[ind].l,l,m,x);
    }
    else
    {
        tr[ind].l=tr[ind_old].l;
        tr[ind].r=++num;
        build(tr[ind_old].r,tr[ind].r,m+1,r,x);
    }
    tr[ind].sum=tr[tr[ind].l].sum + tr[tr[ind].r].sum;
}

int query(int ind,int l,int r,int k)    ///[1,k]
{
    if (r<=k)
        return tr[ind].sum;
    int m=(l+r)>>1,sum=0;
    if (tr[ind].l!=0)  ///存在(该点在线段树中被创建)
        sum+=query(tr[ind].l,l,m,k);
    if (m<k && tr[ind].r!=0)
        sum+=query(tr[ind].r,m+1,r,k);
    return sum;
}

void dfs(int d)
{
    node *p=e[d];
    int dd;
    vis[d]=1;
    while (p)
    {
        dd=p->d;
        if (!vis[dd])
        {
            be[dd]=++num;
            build(be[d],be[dd],1,maxv,p->len);
            dfs(dd);
        }
        p=p->to;
    }
}

int getf(int d)
{
    if (fa[d]==d)
        return d;
    fa[d]=getf(fa[d]);
    return fa[d];
}

void lca(int d)
{
    int dd,x,y;
    node *p=e[d];
    vis[d]=1;
    while (p)
    {
        dd=p->d;
        if (!vis[dd])
        {
            lca(dd);
            x=getf(d);
            y=getf(dd);
            fa[y]=x;
        }
        p=p->to;
    }

    p=point[d];
    while (p)
    {
        dd=p->d;
        ///也许出现一次，也许出现两次
        if (vis[dd] && p->opp->c==0)
        {
            sum[p->num]-=query(be[getf(dd)],1,maxv,p->len)*2;
            p->c=1;
        }

        p=p->to;
    }
}

int main()
{
    node *p,*pp;
    int n,m,u,v,w,k,i;
    scanf("%d%d",&n,&m);
    for (i=1;i<=n;i++)
        fa[i]=i;

    for (i=1;i<n;i++)
    {
        scanf("%d%d%d",&u,&v,&w);

        p=new node();
        p->d=v;
        p->len=w;
        p->to=e[u];
        e[u]=p;

        p=new node();
        p->d=u;
        p->len=w;
        p->to=e[v];
        e[v]=p;
    }

    num=1;
    be[1]=1;

    dfs(1);

    for (i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&k);

        p=new node();
        pp=new node();

        p->d=v;
        p->len=k;
        p->num=i;
        p->to=point[u];
        p->opp=pp;
        p->c=0;
        point[u]=p;

        pp->d=u;
        pp->len=k;
        pp->num=i;
        pp->to=point[v];
        pp->opp=p;
        pp->c=0;
        point[v]=pp;

        sum[i]=query(be[u],1,maxv,k) + query(be[v],1,maxv,k);

//        printf("%d %d
",query(be[u],1,maxv,k),query(be[v],1,maxv,k));
    }

    memset(vis,0,sizeof(vis));
    lca(1);

    for (i=1;i<=m;i++)
        printf("%d
",sum[i]);
    return 0;
}