西电2017ACM网络赛

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 #define ms(a,x) memset(a,x,sizeof(a))

 int n,m,ans;
 ];
 struct node
 {
     int u,v;
 } e[];
 vector<];

 int main()
 {
 //  freopen("test.txt","r",stdin);
     int T;
     scanf("%d",&T);
     while(T--)
     {
         ms(d,);
         scanf("%d%d",&n,&m);
         ; i<=n; i++)
             adj[i].clear();
         ;
         ; i<m; i++)
         {
             scanf("%d%d",&e[i].u,&e[i].v);
             d[e[i].u]++,d[e[i].v]++;
         }
         ; i<m; i++)
         {
             if(d[e[i].u]>d[e[i].v]||
                     d[e[i].u]==d[e[i].v]&&e[i].u>e[i].v)
                 swap(e[i].u,e[i].v);
         }
         ; i<m; i++)
             adj[e[i].u].push_back(e[i].v);
         ; i<=n; i++)
             sort(adj[i].begin(),adj[i].end());
         ; i<m; i++)
         {
             int u=e[i].u,v=e[i].v;
             ,i2=;
             while(i1<adj[u].size()&&i2<adj[v].size())
             {
                 if( adj[u][i1]==adj[v][i2] ) ans++,i1++;
                 else if(adj[u][i1]<adj[v][i2]) i1++;
                 else i2++;
             }
         }
         printf("%d\n",ans);
     }
 }

A

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 #define ms(a,x) memset(a,x,sizeof(a))

 int n,m,ans;
 ][];
 ,,,-};
 ,-,,};

 bool in(int x,int y)
 {
     &&x<n&&y>=&&y<m;
 }
 void dfs(int x,int y)
 {
     if(!in(x,y)) return ;
     if(mp[x][y]=='#') return ;
     mp[x][y]='#';
     ;i<;i++)
         dfs(x+dx[i],y+dy[i]);
 }

 int main()
 {
 //  freopen("test.txt","r",stdin);
     while(cin>>mp[n++]);
     m=strlen(mp[]);
     ;i<n;i++)
         dfs(i,),dfs(i,m-);
     ;i<m;i++)
         dfs(,i),dfs(n-,i);
     ;i<n;i++)
         ;j<m;j++)
             if(mp[i][j]=='*') ans++;
     cout<<ans<<endl;
 }   

B

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;

 LL n,ans; 

 int main()
 {
     while(cin>>n)
     {
         ans=(n+)*n/+;
         cout<<ans<<endl;
     }
 }

C

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 #define ms(a,x) memset(a,x,sizeof(a))

 int n;
 void print(int n,char ch)
 {
     while(n--)
         putchar(ch);
 }
 void up(char be,char en)
 {
     for(char i=be;i<=en;i++)
         putchar(i);
 }
 void down(char be,char en)
 {
     for(char i=be;i>=en;i--)
         putchar(i);
 }

 int main()
 {
     while(~scanf("%d",&n))
     {
         ;i<=n;i++)
         {
             print(-i,' ');
             up();
             down(,'A');
             puts("");
         }
     }
 } 

D

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;

 LL qpow(LL x,LL n,LL mod)
 {
     LL ret=;
     x%=mod;
     )
     {
         ) ret=ret*x%mod;
         x=x*x%mod;
     }
     return ret;
 }
 LL inv(LL x,LL mod)
 {
     ,mod);
 }

 int main()
 {
     LL n,p,ans;
     while(cin>>n>>p)
     {
         ans=n%p*(n+)%p*(*n+)%p*inv(,p)%p;
         cout<<ans<<endl;
     }
 }

E

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;

 struct node
 {
     string x;
     string y;
     bool out;
 }a[];
 int n;

 int main()
 {
     while(cin>>n)
     {
         ;i<n;i++)
         {
             cin>>a[i].x;
             a[i].y=a[i].x;
             sort(a[i].y.begin(),a[i].y.end());
             a[i].out=false;
         }
         ;i<n;i++)
         {
             if(a[i].out==false)
             {
                 cout<<a[i].x;
                 a[i].out=true;
                 ;j<n;j++)
                 {
                     if(a[j].y==a[i].y&&a[j].out==false)
                     {
                         cout<<' '<<a[j].x;
                         a[j].out=true;
                     }
                 }
                 puts("");
             }
         }
     }
 }

F

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 #define ms(a,x) memset(a,x,sizeof(a))

 int n,len;
 LL h[];
 LL s[];

 int main()
 {
     while(~scanf("%d%d",&n,&len))
     {
         ;i<=n;i++)
             scanf("%lld",&h[i]);
         ;i<=len;i++)
             s[i]=s[i-]+h[i];
         ;i<=n;i++)
             s[i]=s[i-]-h[i-len]+h[i];
         LL ans=s[len];
         for(int i=len;i<=n;i++)
             ans=min(ans,s[i]);
         printf("%lld\n",ans);
     }
 }  

G

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;

 int main()
 {
     LL a,b,c,d;
     while(cin>>a>>b>>c>>d)
     {
         LL orz=(a%(c+))^(b%(d+));
         if(orz) puts("NUO!");
         else puts("NO!");
     }
 }

H

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;

 #define MOD 76543

 ,t=;
 LL hs[MOD],head[MOD],Next[MOD],id[MOD],top;
 void insert(LL x,LL y)
 {
     LL k=x%MOD;
     hs[top]=x, id[top]=y, Next[top]=head[k], head[k]=top++;
 }
 LL find(LL x)
 {
     LL k=x%MOD;
     ; i=Next[i])
         if(hs[i]==x)
             return id[i];
     ;
 }
 LL BSGS(LL a,LL b,LL n)
 {
     memset(head,-,sizeof(head));
     top=;
     ) ;
     LL m=sqrt(n*1.0), j;
     LL x=,p=;
     ; i<m; ++i, p=p*a%n) insert(p*b%n,i);
     for(LL i=m; ; i+=m)
     {
          ) return i-j;
         if(i>n)  break;
     }
     ;
 }
 LL qpow(LL x,LL n,LL mod)
 {
     LL ret=;
     )
     {
         ) ret=ret*x%mod;
         x=x*x%mod;
     }
     return ret;
 }

 int main()
 {
     LL ya,yb;
     while(cin>>ya>>yb)
     {
         ||BSGS(t,yb,q)==-)
             puts("No Solution");
         else
         {
             LL xa=BSGS(t,ya,q),xb=BSGS(t,yb,q);
             LL ans=qpow(t,xa*xb,q);
             cout<<ans<<endl;
         }
     }
 }

I

 #include<bits/stdc++.h>
 using namespace std;
 #define ms(a,x) memset(a,x,sizeof(a))

 struct Edge
 {
     int from,to,dist;
 };
 struct HeapNode
 {
     int d,u;
 };

 bool operator < (const HeapNode& a,const HeapNode& b)
 {
     return a.d > b.d;
 }

 const int INF=0x3f3f3f3f;
 int N,M,P,Q,ans;
 ];
 ];
 ];
 ];
 vector<Edge> edges;
 vector<];

 void AddEdge(int from,int to,int dist)
 {
     edges.push_back((Edge){from,to,dist});
     int m=edges.size();
     G[);
 }

 void init()
 {
     ms(jun,);
     ms(done,);
     ms(d,INF);
     edges.clear();
     ;i<=M;i++)
         G[i].clear();
 }

 int Dijkstra(int s,int en)
 {
     priority_queue<HeapNode> Q;
     d[s]=;
     Q.push((HeapNode){,s});
     while(!Q.empty())
     {
         HeapNode x=Q.top();Q.pop();
         int u=x.u;
         if(done[u]) continue;
         done[u]=true;
         if(u==en)//
         {
             ans=d[u];
             return ans;
         }
         ;i<G[u].size();i++)
         {
             Edge& e=edges[G[u][i]];
             if(d[e.to]>d[u]+e.dist)
             {
                 d[e.to]=d[u]+e.dist;
                 p[e.to]=G[u][i];
                 Q.push((HeapNode){d[e.to],e.to});
             }
         }
     }
 }

 int main()
 {
     int T;
     scanf("%d",&T);
     while(T--)
     {
         init();
         scanf("%d",&P);
         while(P--)
         {
             int u,v,d;
             scanf("%d%d%d",&u,&v,&d);
             AddEdge(u,v,d);
             AddEdge(v,u,d);
         }
         int be,en;
         scanf("%d%d",&be,&en) ;
         int ans=Dijkstra(be,en);
         printf();
     }
 }  

J