常州day3

Task1

小 W 得到了一堆石子，要放在 N 条水平线与 M 条竖直线构成的网格的交点上。
因为小 M 最喜欢矩形了， 小 W 希望知道用 K 个石子最多能找到多少四边平行于坐标轴的
长方形，它的四个角上都恰好放着一枚石子。

对于 100%的数据：N<=30000，保证任意两点不重合，K<=N*M

简单题，枚举即可

 #include<stdio.h>
 #include<stdlib.h>
 #include<math.h>
 #include<iostream>
 #include<algorithm>
 using namespace std;
 typedef long long ll;
 ll n,m,k,ans,now,a,b,c,p,q;
 int main(){
     freopen("rectangle.in","r",stdin);
     freopen("rectangle.out","w",stdout);
     cin>>n>>m>>k;
     for(int i=;i<=n;i++){
         a=i;b=k/i;c=k%i;now=p=q=;
         if(b>m) continue;
         now=(a*(a-)/)*(b*(b-)/);
         if(a<n){
             if(c>b) continue;
             p=now+c*(c-)/*a;
         }
         if(b<m){
             if(c>a) continue;
             q=now+c*(c-)/*b;
         }
         ans=max(ans,max(p,q));
     }
     cout<<ans;
     return ;
 }

Task 2

小 W 发现了一个神奇的数列： 这就是著名的 Fibonacci
Sequence = =!。
众所周知，小 M 的数学超级超级好，于是给小 W 出了一道题：
给小 W 两个数 X,Y,其中 X ≤ Y≤ 2^31−1。
小 W 任务就是求出 Fibonacci 数列第 X~Y 项的和除以 10000 的余数。
然而小 W 是数学战五渣，于是只能把这个任务交给机智的你啦。

对于 100%的数据：T<=1000,Y<=2^31-1

简单题，矩阵快速幂裸题

 #include<stdio.h>
 #include<stdlib.h>
 #include<math.h>
 #include<iostream>
 #include<algorithm>
 #include<string.h>
 #define il inline
 using namespace std;
 const int mod=;
 int base[][],ans[][],tmp[][],s,t,T;
 il void mul(int a[][],int b[][],int c[][]){
     memset(tmp,false,sizeof(tmp));
     for(int i=;i<;i++)
         for(int j=;j<;j++)
             for(int k=;k<;k++)
                 tmp[i][j]=(tmp[i][j]+a[i][k]*b[k][j])%mod;
     for(int i=;i<;i++)
         for(int j=;j<;j++)
             c[i][j]=tmp[i][j];
 }
 il int est(int n){
     if(n==) return ;
     if(n==) return ;
     if(n==) return ;
     memset(base,,sizeof(base));
     memset(ans,,sizeof(ans));
     ans[][]=ans[][]=ans[][]=;
     base[][]=base[][]=base[][]=base[][]=base[][]=base[][]=;
     for(int pow=n-;pow;pow>>=){
         if(pow&) mul(ans,base,ans);
         mul(base,base,base);
     }
     return (ans[][]+ans[][]+ans[][]*)%mod;
 }
 il void init(){
     scanf("%d%d",&s,&t);
     printf("%d\n",(mod+est(t)-est(s-))%mod);
 }
 int main(){
     freopen("fibonacci.in","r",stdin);
     freopen("fibonacci.out","w",stdout);
     scanf("%d",&T);
     for(int i=;i<=T;i++) init();
     return ;
 }

Task 3

小 W 千辛万苦做出了数列题，突然发现小 M 被困进了迷宫里。
迷宫是一个有 N(2≤N≤1000)个顶点 M(N−1≤M≤N∗(N − 1)/2 ) 条边的无向连通图。
设 dist1[i]表示在这个无向连通图中， 顶点 i 到顶点 1 的最短距离。
为了解开迷宫，现在要求小 W 在这个图中删除 M − (N − 1)条边，使得这个迷宫变成一
棵树。设 dist2[i]表示在这棵树中，顶点 i 到顶点 1 的距离。
小 W 的任务是求出有多少种删除方案，使得对于任意的 i，满足 dist1[i]=dist2[i]。
快点帮助小 W 救出小 M 吧！

对于 100%的数据：2≤N≤1000

最短路径树计数

预处理最短路

因为每个节点链接到从1出发的最短路的距离相等节点是等价的

所以直接统计即可

 #include<stdio.h>
 #include<iostream>
 #include<stdlib.h>
 #include<algorithm>
 #include<math.h>
 #include<string>
 #include<string.h>
 #include<queue>
 #define il inline
 using namespace std;
 const int N=;
 int n,m,M=,inq[N],d[N],p[N][N],g[N];
 long long ans=;
 queue<int> q;
 struct edge{int next,to,val;
 } e[];
 struct data{int dist,id;
 } b[N];
 il void addedge(int x,int y,int z){
     e[++M]=(edge){g[x],y,z};g[x]=M;
 }
 il bool cmp(data a,data b){
     return a.dist<b.dist;
 }
 int main(){
     freopen("treecount.in","r",stdin);
     freopen("treecount.out","w",stdout);
     scanf("%d%d",&n,&m);
     for(int i=;i<=n+;i++)
         for(int j=;j<=n+;j++)
             p[i][j]=p[j][i]=(<<);
     for(int i=,x,y,z;i<=m;i++){
         scanf("%d%d%d",&x,&y,&z);
         addedge(x,y,z);
         addedge(y,x,z);
         p[x][y]=p[y][x]=z;
     }
     for(int i=;i<=n;i++) d[i]=(<<);
     memset(inq,false,sizeof(inq));
     d[]=;q.push();
     while(!q.empty()){
         int h=q.front();q.pop();inq[h]=false;
         for(int i=g[h];i;i=e[i].next)
             if(d[e[i].to]>d[h]+e[i].val){
                 d[e[i].to]=d[h]+e[i].val;
                 if(!inq[e[i].to]){
                     inq[e[i].to]=true;
                     q.push(e[i].to);
                 }
             }
     }
     for(int i=;i<=n;i++){
         b[i].dist=d[i];
         b[i].id=i;
     }
     sort(b+,b+n+,cmp);
     for(int i=;i<=n;i++){
         int cnt=;
         for(int j=;j<i;j++)
             if(b[j].dist+p[b[j].id][b[i].id]==b[i].dist)
                 cnt++;
         ans=ans*cnt%2147483647ll;
     }
     cout<<ans;
     return ;
 }