UESTC 2016 Summer Training #5 Div.2（未完待续）

A

#include <cstdio>
#include <cstring>
#include <vector>
#define MAXN 100005
#define mem(a) memset(a, 0, sizeof(a))
using namespace std;

int TreeArray[MAXN], Left[MAXN], Right[MAXN], Fork[MAXN];
typedef vector<int> Ve;
vector<Ve>Edge(MAXN);
int N,M;
int key;

void init()//初始化数组和
{
    mem(Left);  mem(Right);
    mem(Fork);  mem(TreeArray);
    for(int i=0;i<MAXN;i++)Edge[i].clear();
}

void DFS(int node)//为每一个node添加一个左值和右值，表示这个节点所
{
    Left[node] = key;
    for(int i=0;i<Edge[node].size();i++)
    {
        key+=1;
        DFS(Edge[node][i]);
    }
    Right[node] = key;
}

int LowBit(int x)//返回的是2^k
{
    return x & (x ^ (x-1));
}

void Edit(int k, int num)//修改节点k，如果是添加一个，代入1，删除一个代入-1
{
    while(k <= N)
    {
        TreeArray[k] += num;
        k += LowBit(k);
    }
}

int GetSum(int k)//得到1...k的和
{
    int sum = 0;
    while(k>=1)
    {
        sum += TreeArray[k];
        k -= LowBit(k);
    }
    return sum;
}

void ReadDataAndDo()
{
    int a,b;
    char ch;
    for(int i=1;i<N;i++)//输入a，b把边存放在容器里面
    {
        scanf("%d%d", &a, &b);
        Edge[a].push_back(b);
    }
    key = 1;    DFS(1);//为每一个节点对应一个左边界和右边界，他自己就存放在左边界里面，而它的管辖范围就是左边界到右边界
    for(int i=1;i<=N;i++)
    {
        Fork[i] = 1;//最初每个Fork上都有一个苹果
        Edit(i,1);//同时更新树状数组的值
    }
    scanf("%d%*c", &M);
    for(int i=0;i<M;i++)
    {
        scanf("%c %d%*c", &ch, &b);
        if(ch == ‘Q‘)//b的子树就是[Left[b], right[b]]
        {
            printf("%d\n", GetSum(Right[b]) - GetSum(Left[b]-1));
        }
        else
        {
            if(Fork[b]) Edit(Left[b],-1);//由于每个节点的编号就是它的左值，所以直接修改左节点
            else Edit(Left[b],1);
            Fork[b] = !Fork[b];//变为相反的状态
        }
    }
}

int main()
{
    while(~scanf("%d", &N))
    {
        init();
        ReadDataAndDo();
    }
    return 0;
}

B

#include <bits/stdc++.h>
using namespace std;
int n,q,x;
int main(){
    int a=0,b=0;
    scanf("%d%d",&n,&q);
    while(q--){
        int tmp;
        scanf("%d",&tmp);
        if(tmp==1){
            scanf("%d",&x);
            a = (n+a-x)%n;
            b = (n+b-x)%n;
            if(x%2) swap(a,b); //当x为奇数时，1,2的位置奇偶性必然改变成相反的
        }else{
            a = (a+n-1)%n;
            b = (b+n+1)%n;
            swap(a,b);//交换奇偶位置
        }
    }
    for(int i=1; i<=n; i++){
        if(i%2) printf("%d ",(a+i-1+n)%n+1);//用1的位置递推所有奇数位置的编号
        else printf("%d ",(b+i-1+n)%n+1); //用2的位置递推所有偶数位置的编号
    }
    return 0;
}

C

#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string.h>
#include <math.h>

#define INF 0x3f3f3f3f
#define eps 1e-6

typedef long long LL;
const double pi = acos(-1.0);
const long long Mod = INF;
using namespace std;

int main()
{
    LL M,N;
    cin >> N >> M;
    LL k = 2;
    LL a = N / M;
    printf("%I64d",a);
    N = (N - a * M) * k;
    while(N)
    {
        a = N / M;
        printf(" %I64d",a);
        k++;
        N = (N - a * M) * k;
    }
    puts("");
    return 0;
}

D

#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string.h>
#include <math.h>

#define INF 0x3f3f3f3f
#define eps 1e-6

typedef long long LL;
const double pi = acos(-1.0);
const long long MOD = 1e9 + 7;
using namespace std;

struct node
{
    int u,v,w;
}edge[10005];

int dis[10005];

int top;

int fun(int N)
{
    int u,v,w;
    for(int i = 1;i <= N;i++)
        dis[i] = INF;
    dis[1] = 0;
    for(int k = 0;k < N - 1;k++)
        for(int i = 0;i < top;i++)
        {
            u = edge[i].u;
            v = edge[i].v;
            w = edge[i].w;
            if(dis[u] + w < dis[v] && dis[u] < INF)
                dis[v] = dis[u] + w;
        }
    for(int i = 0;i < top;i++)
    {
        u = edge[i].u;
        v = edge[i].v;
        w = edge[i].w;
        if(dis[u] + w < dis[v] && dis[u] < INF)
            return 0;
    }
    return 1;
}

void add(int u,int v,int w)
{
    edge[top].u = u;
    edge[top].v = v;
    edge[top++].w = w;
}

int main()
{
    int F,N,M,W,T,S,E;
    cin >> F;
    while(F--)
    {
        top = 0;
        cin >> N >> M >> W;
        for(int i = 0;i < M;i++)
        {
            cin >> S >> E >> T;
            add(S,E,T);
            add(E,S,T);
        }
        for(int i = 0;i < W;i++)
        {
            cin >> S >> E >> T;
            add(S,E,-T);
        }
        if(!fun(N))
            puts("YES");
        else
            puts("NO");
    }
    return 0;
}

E

import java.io.*;
import java.math.BigInteger;
import java.util.*;  

public class Main {
    public static void main(String args[]) throws Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.main(in, out);
        out.close();
    }
}  

class InputReader {
    BufferedReader reader;
    StringTokenizer tokenizer;  

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }  

    public String next() {
        if (!hasNext())
            throw new RuntimeException();
        return tokenizer.nextToken();
    }  

    boolean hasNext() {
        while (tokenizer == null || !tokenizer.hasMoreTokens())
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (Exception e) {
                return false;
            }
        return true;
    }  

    public long nextLong() {
        return Long.parseLong(next());
    }  

    public int nextInt() {
        return Integer.parseInt(next());
    }
}  

class Task {
    BigInteger zero = BigInteger.ZERO;
    BigInteger one = BigInteger.ONE;
    BigInteger ten = BigInteger.TEN;
    final int maxn = 50005;
    BigInteger[] f=new BigInteger[maxn];
    int[] A=new int [15];
    int[] B=new int [15];
    int n,m;
    BigInteger ans;
    BigInteger C(int n,int m)
    {
        if(m>n)
            return zero;
        m=Math.min(m, n-m);
        BigInteger res=one;
        for(int i=n;i>=n-m+1;--i)
        {
            res=res.multiply(BigInteger.valueOf(i)).divide(BigInteger.valueOf(n-i+1));
        }
        return res;
    }
    void gao(int x,int cnt,int remain)
    {
        if(x<0)
        {
            if((cnt&1)>0)
                ans=ans.subtract(C(remain+n-1,n-1));
            else
                ans=ans.add(C(remain+n-1,n-1));
            return;
        }
        gao(x-1,cnt,remain);
        if(remain>B[x])
            gao(x-1,cnt+1,remain-B[x]-1);
    }
    void main(InputReader in, PrintWriter out) throws Exception {
        int i,j;
        ans=zero;
        int T;
        T=in.nextInt();
        for(int cas=0;cas<T;++cas)
        {
            ans=zero;
            n=in.nextInt();
            m=in.nextInt();
            for(i=0;i<n;++i)
            {
                A[i]=in.nextInt();
                B[i]=in.nextInt();
                m-=A[i];
                B[i]-=A[i];
            }
            if(m<0)
            {
                out.println(0);
            }
            else if(m==0)
            {
                out.println(1);
            }
            else
            {
                gao(n-1,0,m);
                out.println(ans);
            }
        }
    }
}

F

题意：给你一个数N，让你用前N个数，通过N-1次加减乘除运算得到24。让你输出合法的计算过程。

做法：

当N<4时，很显然，无法得到24点；

当N>=4时，可以得到24点，这时，我们分成两种情况进行构造。

1）当N为偶数时，由1，2，3，4显然可以构造出24，剩下的N-4（偶数）个数只需两两相减，并最后与24相乘即可。

2）当N为奇数时，由1，2，3，4，5显然可以构造出24，剩下的N-5（偶数）个数只需两两相减，并最后与24相乘即可。具体实现方法见代码。

#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string.h>
#include <math.h>

#define INF 0x3f3f3f3f
#define eps 1e-6

typedef long long LL;
const double pi = acos(-1.0);
const long long MOD = 1e9 + 7;
using namespace std;

int a[12] = {0};

int main()
{
    int N;
    cin >> N;
    int ok = 1;
    if(N < 4)
    {
        puts("NO");
        return 0;
    }
    else
        puts("YES");
    if(N % 2 == 0)
    {
        printf("2 * 3 = 6\n");
        printf("4 * 6 = 24\n");
        printf("24 * 1 = 24\n");
        for(int i = 5;i < N;i += 2)
        {
            printf("%d - %d = 1\n",i + 1,i);
            printf("24 * 1 = 24\n");
        }
    }
    else
    {
        printf("4 * 5 = 20\n");
        printf("20 + 3 = 23\n");
        printf("23 + 2 = 25\n");
        printf("25 - 1 = 24\n");
        for(int i = 6;i < N;i += 2)
        {
            printf("%d - %d = 1\n",i + 1,i);
            printf("24 * 1 = 24\n");
        }
    }
    return 0;
}

G

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
#define esp 0.00000000001
const int N=2e5+10,M=1e6+10,inf=1e9;
#define mem(s) memset(s,0,sizeof(s))
int n,m,head[N],t,vis[N],deep[N],fa[N][20];
int a[N];
int flag[N];
struct ss {
  int to,next;
}e[N*2];
void add(int u,int v) {
   e[t].next=head[u];e[t].to=v;head[u]=t++;
}
void init() {
  t=1;mem(head);mem(vis);mem(fa);mem(deep);mem(flag);
}
void dfs(int x) {
    vis[x]=1;
    for (int i=1; i<=18 ;i++) {
        if(deep[x]<(1<<i)) break;
        fa[x][i] = fa[fa[x][i-1]][i-1];
    }
    for (int i=head[x];i;i=e[i].next) {
        if(vis[e[i].to]) continue;
        deep[e[i].to]=deep[x]+1;
        fa[e[i].to][0]=x;
        dfs(e[i].to);
    }
}
int RMQ_LCA(int x,int y) {
    if(deep[x]<deep[y]) swap(x,y);
    int d=deep[x]-deep[y];
    for (int i=0; i<=18 ;i++)
        if((1<<i)&d) x=fa[x][i];
    for (int i=18; i>=0 ;i--) {
        if(fa[x][i]!=fa[y][i]) {
            x=fa[x][i];y=fa[y][i];
        }
    }
    if(x==y) return x;
    else return fa[x][0];
}
int Dis_LCA(int x,int y) {
    int LCA= RMQ_LCA(x,y);
    return (deep[x]+deep[y]-2*deep[LCA]);
}
struct is
{
    int pos,step,pre;
};
int main()
{
    int x,y,z,i,t;
    while(~scanf("%d",&x))
    {
        queue<is>q;
        init();
        for(i=2;i<=x;i++)
        scanf("%d",&a[i]);
        for(i=x;i>=2;i--)
        {
            add(a[i],i);
            add(i,a[i]);
        }
        dfs(1);
        int maxdeep=0;
        int pre=0;
        is st;
        st.pos=1;
        st.step=0;
        st.pre=0;
        q.push(st);
        flag[1]=1;
        ll ans=0;
        while(!q.empty())
        {
            is vv=q.front();
            q.pop();
            if(vv.pos!=1)
            {
                ans+=Dis_LCA(vv.pos,pre);
            }
            pre=vv.pos;
            maxdeep=vv.step;
            int pos=vv.pos;
            for(i=head[vv.pos];i;i=e[i].next)
            {
                if(flag[e[i].to])
                continue;
                is en;
                en.pos=e[i].to;
                en.step=vv.step+1;
                en.pre=vv.pos;
                flag[e[i].to]=1;
                q.push(en);
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}

I

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <set>
using namespace std;
typedef long long ll;
typedef unsigned long long Ull;
#define MM(a,b) memset(a,b,sizeof(a));
const double eps = 1e-10;
const int  inf =0x7f7f7f7f;
const double pi=acos(-1);
const int maxn=40000;

struct node {
   int x,y;
   bool operator<(const node&a) const{
       return this->x<a.x;
   }
};
vector<node> A,B;
char s[10000];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        A.clear();B.clear();
        for(int i=1;i<=n;i++)
        {
            scanf("%s",s);
            int l=0,r=0;
            for(int j=0;s[j]!=‘\0‘;j++)
            {
                 if(s[j]==‘(‘) r++;
                 else if(!r) l++;
                 else r--;
            }
            if(l>r) B.push_back((node){r,l-r});
            else  A.push_back((node){l,r-l});
        }

        sort(A.begin(),A.end());
        sort(B.begin(),B.end());
        int cntA=0,cntB=0;

        bool flag=true;
        for(int i=0;i<A.size();i++)
        {
            if(A[i].x>cntA) {flag=false;break;}
            cntA+=A[i].y;
        }

        for(int i=0;i<B.size();i++)
        {
            if(B[i].x>cntB) {flag=false;break;}
            cntB+=B[i].y;
        }

        if(cntA!=cntB) flag=false;
        printf("%s\n",flag?"Yes":"No");
    }
    return 0;
}

K

题意：让你读完文章，并依次得到每个人的比赛次数。一共11个人，并且已经个了3个，你可以用这三个数检验你自己的答案。

傻逼题，细心阅读就可以了

#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string.h>
#include <math.h>

#define INF 0x3f3f3f3f
#define eps 1e-6

typedef long long LL;
const double pi = acos(-1.0);
const long long Mod = INF;
using namespace std;

int a[12] = {5,20,12,2,1,4,6,1,4,4,1,0};

int main()
{
    int n;
    cin >> n;
    printf("%d\n",a[n]);
    return 0;
}
时间： 2024-08-12 19:46:01

UESTC 2016 Summer Training #5 Div.2（未完待续）的相关文章

UESTC 2016 Summer Training #1 Div.2

最近意志力好飘摇..不知道坚不坚持得下去.. 这么弱还瞎纠结...可以滚了.. 水题都不会做.. LCS (A) 水 LCS (B) 没有看题 Gym 100989C 水 1D Cafeteria (B) 不会捉 Gym 100989E 水 Gym 100989F 水 Mission in Amman (B) 没看题 Queue (A) 感觉题意理解得有问题啊 1 #include <iostream> 2 #include <cstdio> 3 #include <cstr

UESTC 2016 Summer Training #2 Div.2 A dp、递推、多阶段问题

A - A Time Limit:336MS     Memory Limit:1572864KB     64bit IO Format:%lld & %llu Submit Status Practice SPOJ AMR11A Description Thanks a lot for helping Harry Potter in finding the Sorcerer's Stone of Immortality in October. Did we not tell you that

UESTC 2016 Summer Training #1 Div.2 E - Accepted Passwords 讨论

E - Accepted Passwords Time Limit:1000MS     Memory Limit:262144KB     64bit IO Format:%I64d & %I64u Submit Status Practice Gym 100989E Description standard input/output Islam is usually in a hurry. He often types his passwords incorrectly. He hates

UESTC 2016 Summer Training #1 Div.2 F - Mission in Amman (A) 动态维护(刷新:--、++)

F - Mission in Amman (A) Time Limit:1000MS     Memory Limit:262144KB     64bit IO Format:%I64d & %I64u Submit Status Practice Gym 100989F Description standard input/output You must have heard about Agent Mahone! Dr. Ibrahim hired him to catch the che

UESTC 2016 Summer Training #1 Div.2 L - Plus or Minus (A) dfs

L - Plus or Minus (A) Time Limit:1000MS     Memory Limit:262144KB     64bit IO Format:%I64d & %I64u Submit Status Practice Gym 100989L Description standard input/output AbdelKader enjoys math. He feels very frustrated whenever he sees an incorrect eq

UESTC 2016 Summer Training #1 Div.2 H - Queue (A) 贪心

H - Queue (A) Time Limit:1000MS     Memory Limit:262144KB     64bit IO Format:%I64d & %I64u Submit Status Practice Gym 100989H Description standard input/output After the data structures exam, students lined up in the cafeteria to have a drink and ch

UESTC 2016 Summer Training #2 Div.2 E 分解质因素(除了以后剩下的可能也是个素数)

E - E Time Limit:3000MS     Memory Limit:1572864KB     64bit IO Format:%lld & %llu Submit Status Practice SPOJ AMR11E Description Arithmancy is Draco Malfoy's favorite subject, but what spoils it for him is that Hermione Granger is in his class, and

UESTC 2014 Summer Training #18 Div.2

A.UVALive 6661 题意从1~N中选k个数,和为s的方案数 第一眼搜索,估计错状态量,又去yydp...浪费大量时间 数据很小的,状态数都不会超过2^N...直接dfs就过了 //state二进制表示选取的数 #include <iostream> #include <cstdio> #include <cstdlib> #include <cstring> using namespace std; const int maxn = 200; in

UESTC 2014 Summer Training #3 Div.2

(更新中) A:ZOJ 3611 BFS+状态压缩 [题意]:给定一张n*m的图,图上每个点有如下情况:L,R,D,U:代表在该点上只能往它已经给定的方向前进.#,W:不能走到该点.$:走到该点,可以花两分钟得到一分值,然后可以从该点向任意方向走.0:走到该点后可以向任意方向走.然后给你起点和终点坐标,问是否能从起点走到终点,如果能,求出可获得的最大分值以及与之对应达到该最大分值所需的的最小时间花 费.(其中起点和终点坐标可以相同)[知识点]:BFS+状态压缩[题解]:我觉得超级棒的题!真心感觉