CCCC L2-025 L2-026 L2-027

赛场上第一题内存超限，第二题超时，其实只要稍微一转换就能过，没想到啊，可能与平时做题有关系
1、L2-025 分而治之
内存超限是因为我用邻接矩阵存的，不应该，邻接表只学过数组怎么实现，其实vector更直观，也易实现

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
#define N 100005
vector<int>ve[N];
bool vis[N];
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    for(int i = 0;i < m;++i)
    {
        int x,y;
        scanf("%d %d",&x,&y);
        ve[x].push_back(y);
        ve[y].push_back(x);
    }
    int k;
    scanf("%d",&k);
    for(int i = 0;i < k;++i)
    {
        int num;
        scanf("%d",&num);
        memset(vis,false,sizeof(vis));
        for(int j = 0;j < num;++j)
        {
            int t;
            scanf("%d",&t);
            vis[t] = true;
        }
        bool flag = false;
        for(int j = 1;j <= n;++j)
        {
            if(!vis[j] && !flag){
                for(int x = 0;x < ve[j].size();++x)
                {
                    if(!vis[ve[j][x]]){
                        cout << "NO" << endl;
                        flag = true;
                        break;
                    }
                }
            }
        }
        if(!flag){
            cout << "YES" << endl;
        }
    }
    return 0;
}

2、L2-026 小字辈
大部分都是孩子找祖宗，用dfs+剪枝做的，我用的bfs，原先祖宗找孩子，每次都要遍历一遍数组，其实预处理一下就可以了，用vector储存孩子

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<cmath>
#include<queue>
using namespace std;
#define N 100005
vector<int>ve[N];
int main()
{
    int n;
    scanf("%d",&n);
    int root;
    for(int i = 1;i <= n;++i)
    {
        int x;
        scanf("%d",&x);
        if(x == -1){
            root = i;
        }
        else{
            ve[x].push_back(i);
        }
    }
    queue<int>que;
    que.push(root);
    int Front = 0;
    int ptr[N];
    int cnt = 0;
    while(!que.empty())
    {
        int rear = 0;
        int tmp[N];
        Front = 0;
        cnt++;
        while(!que.empty())
        {
            int x = que.front();
            ptr[Front++] = x;
            que.pop();
            for(int i = 0;i < ve[x].size();++i)
            {
                tmp[rear++] = ve[x][i];
            }
        }
        for(int i = 0;i < rear;++i)
            que.push(tmp[i]);
    }
    printf("%d\n",cnt);
    for(int i = 0;i < Front;++i)
    {
        if(i == Front - 1){
            printf("%d\n",ptr[i]);
        }
        else{
            printf("%d ",ptr[i]);
        }
    }
    return 0;
}

3、L2-027 名人堂与代金券
这个最后弄并列的时候，有点问题，没得满分

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
using namespace std;
#define N 10005
typedef struct Node{
    string s;
    int n;
}Node;
Node stu[N];
bool cmp(const Node &p,const Node &q)
{
    if(p.n == q.n){
        return p.s < q.s;
    }
    else{
        return p.n > q.n;
    }
}
int main()
{
    int n,g,k;
    scanf("%d %d %d",&n,&g,&k);
    int sum = 0;
    for(int i = 0;i < n;++i)
    {
        string s;
        int n;
        cin >> s >> n;
        stu[i].s = s;
        stu[i].n = n;
        if(n >= 60 && n < g){
            sum += 20;
        }
        else{
            if(n >= g && n <= 100){
                sum += 50;
            }
        }
    }
    sort(stu,stu + n,cmp);
    cout << sum << endl;
    int x = 1;
    int flag = stu[0].n;
    for(int i = 0;i < k;++i)
    {
        if(flag == stu[i].n){
            cout << x << " ";
        }
        else{
            x = i + 1;
            cout << x << " ";
            flag = stu[i].n;
        }
        cout << stu[i].s << " " << stu[i].n << endl;
    }
    for(int i = k;i < n;++i)
    {
        if(stu[i].n == stu[k - 1].n){
            cout << x << " " << stu[i].s << " " << stu[i].n << endl;
        }
        else break;
    }
    return 0;
}

在此写出图的三种常用的存储结构：

1.邻接矩阵
int E[110][110];
E[1][2]=1;
E[5][3]=0;

2.邻接链表
#include <vector>
#include <cstdio>
using namespace std;

const int MAXN = 100000;

vector<int> edge[MAXN];

int main()
{
    int n, m; //n顶点,m边
    for(int i = 0; i < m; ++i)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        edge[a].push_back(b);
        //edge[b].push_back(a); //如果是无向图要执行这句，来回都要存！
    }
    return 0;
}

3.前向星 
// edges[i].to表示第i条边的终点
// edges[i].next表示与第i条边同起点的下一条边的存储位置
// head[i]表示以i为起点的第一条边存储的位置
typedef struct edge{
    int to; 
    int next;
    //int w;     //若有权值
}edge;

edge edges[1010];     // 总共不超过1000条边。
int head[110];        // 不超过100个点。
int cnt;              // 输入的第cnt条边

void init() {         // 初始化。
    memset(head, -1, sizeof(head));
    cnt = 0;
}

void addEdge(int u,int v) {
    //edge[cnt].w = w;
    edges[cnt].to = v;    
    edges[cnt].next = head[u];     
    head[u] = cnt++;
}

int main() {
    int n, t1, t2;
    init();
    scanf("%d", &n);
    for(int i = 0; i < n; i++) {
        scanf("%d%d", &t1, &t2);
        addEdge(t1, t2);
        // addEdge(t2, t1);
    }
}

树的存储结构：
https://blog.csdn.net/smile_from_2015/article/details/63687696