练习备份1

#include<vector>
#include<cstdio>
#include<iostream>
using namespace std;
vector<vector<int> >name;
int main(void)
{
    int n;
    cin >> n;
    for(int i=0;i<n;i++)
    {
        int k , data;
        cin >> k;
        vector<int>temp;
        for(int j=0;j<k;j++)
        {
            cin >> data;
            temp.push_back(data);
        }
        name.push_back(temp);
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<name[i].size();j++)
        {
            printf("%d  ",name[i][j]);
        }
        printf("
");
    }
    return 0;
} 

#include<cstdio>
#include<iostream>
#include<vector>
using namespace std;
int main(void)
{
    vector<int>vi[100];
    for(int i=0;i<5;i++) vi[0].push_back(i);
    vector<int>::iterator it;
    for(it=vi[0].begin();it!=vi[0].end();it++)
    {
        printf("%d ",*it);
    }
    return 0;
}

#include<vector>
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int main(void)
{
    vector<int>vi;
    for(int i=1;i<=3;i++) vi.push_back(i);
    vi.pop_back();
    for(int i=0;i<vi.size();i++) printf("%d ",vi[i]); 
    return 0;
}

#include<stdio.h>
#include<vector>
using namespace std;
int main(void)
{
    vector<int>vi;
    for(int i=0;i<3;i++) vi.push_back(i);
    printf("%d",vi.size());
    return 0;
 } 

#include<cstdio>
#include<vector>
using namespace std;
int main(void)
{
    vector<int>vi;
    for(int i=1;i<=3;i++) vi.push_back(i);
    vi.clear();
    printf("%d",vi.size()); 
    return 0;
}


#include<cstdio>
#include<vector>
using namespace std;
int main(void)
{
    vector<int>vi;
    for(int i=1;i<=5;i++) vi.push_back(i);
    vi.insert(vi.begin()+2,-1);
    for(int i=0;i<vi.size();i++) printf("%d ",vi[i]);
    printf("
");
    for(vector<int>::iterator it=vi.begin();it!=vi.end();it++) printf("%d ",*(it));
    printf("
");
    
    return 0;
}

#include<cstdio>
#include<vector>
using namespace std;
int main(void)
{
    vector<int> vi;
    for(int i=5;i<=9;i++) vi.push_back(i);
    vi.erase(vi.begin()+3);
    for(vector<int>::iterator it=vi.begin();it!=vi.end();it++) printf("%d ",*(it));
    return 0;
}

#include<cstdio>
#include<vector>
using namespace std;
int main(void)
{
    vector<int> vi;
    for(int i=1;i<=10;i++) vi.push_back(i);
    vi.erase(vi.begin()+5,vi.end());
    for(int i=0;i<vi.size();i++) printf("%d ",vi[i]);
    return 0;
}

#include<cstdio>
#include<set>
using namespace std;
int main(void)
{
    set<int> st;
    st.insert(3);
    st.insert(5);
    st.insert(2);
    st.insert(3);
    for(set<int>::iterator it=st.begin();it!=st.end();it++) printf("%d ",*it);
    return 0;
}

#include<cstdio>
#include<set>
using namespace std;
int main(void)
{
    set<int>st;
    for(int i=1;i<=10;i++) st.insert(i);
    set<int>::iterator it=st.find(3);
    st.erase(it);
    for(set<int>::iterator it=st.begin();it!=st.end();it++) printf("%d ",*it);
    return 0;
}

#include<set>
#include<cstdio>
using namespace std;
int main(void)
{
    set<int>st;
    st.insert(100);
    st.insert(200);
    st.insert(100);
    st.insert(300);
    st.erase(st.find(100));
    for(set<int>::iterator it=st.begin();it!=st.end();it++) printf("%d ",*it);
    return 0;
}

#include<cstdio>
#include<set>
using namespace std;
int main(void)
{
    set<int>st;
    
    for(int i=1;i<=100;i++) st.insert(i);
    set<int>::iterator it=st.find(90);
    st.erase(st.begin(),it);
    for(set<int>::iterator it=st.begin();it!=st.end();it++) printf("%d ",*it);
    
    return 0;
}

#include<cstdio>
#include<set>
using namespace std;
int main(void)
{
    set<int>st;
    st.insert(100);
    st.insert(200);
    st.insert(300);
    st.insert(400);
    printf("%d",st.size());
    return 0;
}

#include<set>
#include<cstdio>
using namespace std;
int main(void)
{
    set<int>st;
    st.insert(1); st.insert(3);
    st.clear();
    printf("%d",st.size());
    return 0;
}

#include<unordered_set>
#include<cstdio>
#include<iostream>
using namespace std;
int main(void)
{
    unordered_set<int> st;
    st.insert(100);
    st.insert(2);
    st.insert(399);
    for(unordered_set<int>::iterator it=st.begin();it!=st.end();it++) printf("%d",*it);    
} 

#include<cstdio>
#include<set>
using namespace std;
int main(void)
{
    multiset<int>st;
    st.insert(100);
    st.insert(200);
    st.insert(100);
    for(multiset<int>::iterator it=st.begin();it!=st.end();it++) printf("%d ",*it);
    
    return 0;
}

#include<iostream>
#include<set>
#include<map>
using namespace std;
int main(void)
{
    map<string,int>mp1;
    map<set<int>,int>mp2;
    map<int,set<int> >mp3;
    map<char,int>mp4;
    mp4['a']=1;
    mp4['b']=2;
    mp4['c']=3;
    mp4['d']=4;
    //printf("%d %d",mp4['a'],mp4['b']);
    for(map<char,int>::iterator it=mp4.begin();it!=mp4.end();it++) printf("%c %d
",it->first,it->second);
    return 0;
}

#include<map>
#include<cstdio>
using namespace std;
int main(void)
{
    map<char ,int >mp;
    mp['a']=1;
    mp['b']=2;
    mp['c']=3;
    mp['d']=4;
    //printf("%d %d",mp4['a'],mp4['b']);
    for(map<char,int>::iterator it=mp.begin();it!=mp.end();it++) printf("%c %d
",it->first,it->second);
    return 0;
}

#include<map>
#include<cstdio>
#include<string>
#include<iostream>
using namespace std;
int main(void)
{
    map<int,string>mp;
    mp[0]="hello";
    mp[4]="world";
    map<int,string>::iterator it=mp.find(4);
    printf("%d %s",it->first,(it->second).c_str());    
    return 0;
}

#include<cstdio>
#include<map>
using namespace std;
int main(void)
{
    map<char,int>mp;
    mp['a']=1;
    mp['b']=2;
    mp['c']=3;
    map<char,int>::iterator it=mp.find('b');
    mp.erase(it);
    for(map<char,int>::iterator t=mp.begin();t!=mp.end();t++) printf("%c %d
",t->first,t->second);
    
    return 0;    
}

#include<cstdio>
#include<map>
using namespace std;
int main(void)
{
    map<char,int>mp;
    mp['a']=1;
    mp['b']=2;
    mp['c']=3;
    map<char,int>::iterator it=mp.find('b');
    mp.erase(it,mp.end());
    for(map<char,int>::iterator t=mp.begin();t!=mp.end();t++) printf("%c %d
",t->first,t->second);
    
    return 0;
}


#include<cstdio>
#include<map>
using namespace std;
int main(void)
{
    map<char,int>mp;
    mp['a']=1;
    mp['b']=2;
    mp['c']=3;
    map<char,int>::iterator it=mp.find('d');
    //printf("%c %d
",it->first,it->second);
    if(it==mp.end()) printf("don.t have.
");
    //mp.erase(it,mp.end());
    for(map<char,int>::iterator t=mp.begin();t!=mp.end();t++) printf("%c %d
",t->first,t->second);
    
    return 0;
}

#include<map>
#include<cstdio>
using namespace std;
int main(void)
{
    multimap<char,int>mp;
    
    return 0;
}

#include<cstdio>
#include<queue>
using namespace std;
int main(void)
{
    priority_queue<int>q;
    q.push(1);
    q.push(3);
    q.push(2);
    while(!q.empty())
    {
        int data=q.top();
        printf("%d ",data);
        q.pop();
    }
    return 0;
}

#include<cstdio>
#include<queue>
using namespace std;
int main(void)
{
    priority_queue<int,vector<int>,less<int> >q1;
    q1.push(1); q1.push(2); q1.push(5); q1.push(2);
    priority_queue<int,vector<int>,greater<int> >q2;
    q2.push(1); q2.push(2); q2.push(5); q2.push(2);
    while(!q1.empty())
    {
        int data = q1.top(); q1.pop();
        printf("%d ",data);
    }
    printf("
");
    while(!q2.empty())
    {
        int data = q2.top();q2.pop();
        printf("%d ",data);
    }
    return 0;    
} 

#include<queue>
#include<string>
#include<cstdio>
using namespace std;
struct fruit{
    string name;
    int price;
    friend bool operator<(const fruit &f1,const fruit &f2)
    {
        return f1.price<f2.price;
    }
}f1,f2,f3;
int main(void)
{
    priority_queue<fruit>q;
    f1.name="桃子"; f1.price=3;
    f2.name="梨子"; f2.price=4;
    f3.name="苹果"; f3.price=1;
    q.push(f1); q.push(f2); q.push(f3);
    while(!q.empty())
    {
        fruit temp = q.top(); q.pop();
        printf("%s %d
",temp.name.c_str(),temp.price);    
    } 
    return 0;
}

#include<cstdio>
#include<string>
#include<time.h>
#include<queue>
using namespace std;
struct fruit{
    string name;
    int price;
}f1,f2,f3;
struct cmp{
    bool operator()(const fruit &f1,const fruit &f2)
    {
        return f1.price<f2.price;
    }
};
int main(void)
{
    int a=clock();
    priority_queue<fruit,vector<fruit>,cmp>q;
    f1.name="桃子"; f1.price=3;
    f2.name="梨子"; f2.price=4;
    f3.name="苹果"; f3.price=1;
    q.push(f1); q.push(f2); q.push(f3);
    while(!q.empty())
    {
        fruit temp = q.top(); q.pop();
        printf("%s %d
",temp.name.c_str(),temp.price);    
    } 
    int b=clock();
    printf("%dms.",b-a);
    return 0;
}

#include<string>
#include<cstdio>
using namespace std;
int main(void)
{
    string str="abcd";
    for(int i=0;i<str.length();i++) printf("%c",str[i]);
    printf("
%s",str.c_str());
    printf("
");
    for(string::iterator it=str.begin();it!=str.end();it++) printf("%c",*it);
    return 0;
}

#include<cstdio>
#include<string>
using namespace std;
int main(void)
{
    string str="abc",str2="def";
    //str.insert(3,str2);
    str.insert(str.end(),str2.begin(),str2.end());
    printf("%s",str.c_str());
    
    return 0;    
} 

#include<string> 
#include<cstdio>
using namespace std;
int main(void)
{
    string str="abcdefghijklmn";
    string str1=str.substr(0,5);
    string str2=str.substr(2,5);
    printf("%s
%s
",str1.c_str(),str2.c_str());
    
    return 0;
}

#include<string>
#include<cstdio>
using namespace std;
int main(void)
{
    if(string::npos == -1) printf("string::npos=%d
",string::npos);
    if(string::npos == (unsigned int)(4294967295))printf("string::npos=%u
",string::npos);
    return 0;
}

#include<cstdio>
#include<string>
#include<utility>
using namespace std;
int main(void)
{
    pair<string,int>p[3];
    p[0].first="hello"; p[0].second=1;
    p[1]=make_pair("world",2);
    p[2]=pair<string,int>("hhhh",3);
    for(int i=0;i<3;i++)
    {
        printf("%s %d
",p[i].first.c_str(),p[i].second);
    }
    return 0;    
}

#include<utility>
#include<map>
#include<string>
using namespace std;
int main(void)
{
    map<string,int>mp;
    mp.insert(make_pair("hello",1));
    mp.insert(pair<string,int>("world",2));
    for(map<string,int>::iterator it=mp.begin();it!=mp.end();it++) printf("%s %d
",it->first.c_str(),it->second);
    return 0;    
} 

#include<cstdio>
#include<algorithm>
using namespace std;
int main(void)
{
    int a[]={1,2,3,4,5};
    do{
        printf("%d %d %d %d %d
",a[0],a[1],a[2],a[3],a[4]);
    }while(next_permutation(a,a+5));
    fill(a,a+5,1);
    printf("


"); 
    do{
        printf("%d %d %d %d %d
",a[0],a[1],a[2],a[3],a[4]);
    }while(next_permutation(a,a+5));
    return 0;
}


#include<cstdio>
#include<vector>
using namespace std;
const int MAXV = 1000;
const int INF = 1000000000;
const int Inf = 0x3fffffff; 
int n,G[MAXV][MAXV];
bool vis[MAXV]={false};
void DFS(int u,int depth)
{
    vis[u]=true;
    for(int v=0;v<n;v++)
    {
        if(!vis[v] && G[u][v]!=INT) DFS(v,depth+1);
    }
}
void DFSTrave()
{
    for(int u=0;u<n;u++)
    {
        if(!vis[u]) DFS(u,1);
    }
}
int main(void)
{
    //printf("%d
",INF);
    //printf("%d
",Inf);
    
    return 0;
}

#include<cstdio>
#include<vector>
using namespace std;
const int MAXV = 1000;
const int INF = 0x3fffffff;
vector<int>Adj[MAXV];
bool vis[MAXV]={false};
void DFS(int u,int depth)
{
    vis[u]=true;
    for(int i=0;i<Adj[u].size();i++)
    {
        int v=Adj[u][i];
        if(!vis[v]) DFS(v,depth+1); 
    }
}
void DFSTrave()
{
    for(int v=0;v<n;v++)
    {
        if(!vis[u]) DFS(u,1);
    }
}
int main(void)
{
    return 0;
}

#include<vector>
#include<set>
#include<map>
#include<cstdio>
#include<iostream>
#include<string>
#include<queue>
#include<cstring>
using namespace std;
const int MAXV = 1000;

struct Gang{
    string name;
    int numberOfPerson;
    Gang(string _name,int _numberOfPerson)
    {
        name=_name;
        numberOfPerson=_numberOfPerson;
    }
    friend bool operator<(const Gang &g1,const Gang &g2)
    {
        return g1.name<g2.name;
    }
};
queue<Gang>ans;


int m,k,n,cnt;
map<string,int>NameToInt;
map<int,string>IntToName;
map<string,int>Gang;
int d[MAXV]={0},vis[MAXV]={0};
int G[MAXV][MAXV]={0}; 
void DFS(int u,int &boss,int &number,int &sumValue)
{
    vis[u]=true;
    number++;
    if(d[u]>d[boss]) boss=u;
    for(int v=0;v<n;v++)
    {
        if(G[u][v]!=0)
        {
            sumValue+=G[u][v];
            G[u][v]=G[v][u]=0;
            if(vis[v]==0) DFS(v,boss,number,sumValue); 
        }
    }
}
void DFSTrave()
{
    for(int u=0;u<n;u++)
        if(!vis[u])
        {
            int boss=u,number=0,sumValue=0;
            DFS(u,boss,number,sumValue);
            printf("test boss = %s number = %d sumValue = %d
",IntToName[boss].c_str(),number,sumValue);
            if(number>2 && sumValue>k) Gang[IntToName[boss]]=number;
        }
}
int main(void)
{
    cin>>m>>k;
    for(int i=0;i<m;i++)
    {
        string person1,person2;
        int w;
        cin >> person1 >> person2 >> w;
        if(NameToInt.find(person1)==NameToInt.end())
        {
            NameToInt[person1]=n;
            IntToName[n]=person1;
            n++;
        }
        if(NameToInt.find(person2)==NameToInt.end())
        {
            NameToInt[person2]=n;
            IntToName[n]=person2;
            n++;
        }
        //设置点权值 
        int u=NameToInt[person1],v=NameToInt[person2];
        d[u]+=w;
        d[v]+=w;
        //设置边权值 
        G[u][v]+=w;
        G[v][u]+=w; 
    }
    printf("

");
    for(map<string,int>::iterator it=NameToInt.begin();it!=NameToInt.end();it++) printf("%s %d   ",it->first.c_str(),it->second); 
    printf("
");
    for(map<int,string>::iterator it=IntToName.begin();it!=IntToName.end();it++) printf("%d %s   ",it->first,it->second.c_str());
    printf("
");
    for(int i=0;i<n;i++) printf("%d     ",d[i]);
    printf("
");
    DFSTrave();
        
    while(!ans.empty())
    {
        Gang temp=ans.front(); ans.pop();
        printf("%s %d
",temp.name.c_str(),temp.numberOfPerson);    
    } 
    *
    printf("sum = %d
",Gang.size());
    for(map<string,int>::iterator it=Gang.begin();it!=Gang.end();it++) printf("%s %d
",it->first.c_str(),it->second);
    return 0;

8 59
AAA BBB 10
BBB AAA 20
AAA CCC 40
DDD EEE 5
EEE DDD 70
FFF GGG 30
GGG HHH 20
HHH FFF 10

} 

#include<iostream>
#include<string>
#include<map>
using namespace std;
const int maxn = 2010;
const int INF = 0xFFFFFFF;
map<string,int>stringToInt;
map<int,string>intToString;
map<string,int>Gang;
int G[maxn][maxn]={0},weight[maxn]={0};
int n,k,numPerson=0;
bool vis[maxn]={false};
void DFS(int u,int &head,int &numMember,int &totalValue)
{
    vis[u]=true;
    numMember++;
    if(weight[head]<weight[u]) head=u;
    for(int v=0;v<numPerson;v++)
    {
        if(G[u][v])
        {
            totalValue+=G[u][v];
            G[u][v]=G[v][u]=0;
            if(vis[v]==false) DFS(v,head,numMember,totalValue);
        }
    }
}
void DFSTrave()
{
    for(int u=0;u<numPerson;u++)
    {
        if(vis[u]==false)
        {
            int head=u,numMember=0,totalValue=0;
            DFS(u,head,numMember,totalValue);
            if(numMember>2 && totalValue>k) Gang[intToString[head]]=numMember;
        }
    }
}
int change(string str)
{
    if(stringToInt.find(str)!=stringToInt.end()) return stringToInt[str];
    else 
    {
        stringToInt[str]=numPerson;
        intToString[numPerson]=str;
    }
    return numPerson++;
}
int main(void)
{
    int w;
    string str1,str2;
    cin >> n >> k;
    for(int i=0;i<n;i++)
    {
        cin >> str1 >> str2 >> w;
        int id1=change(str1);
        int id2=change(str2);
        weight[id1]+=w;
        weight[id2]+=w;
        G[id1][id2]+=w;
        G[id2][id1]+=w;
    }    
    DFSTrave();
    printf("%d
",Gang.size());
    for(map<string,int>::iterator it=Gang.begin();it!=Gang.end();it++) printf("%s %d
",it->first.c_str(),it->second);
    return 0;
}


int n,G[maxn][maxn];
bool inq[maxn]={false}; 
void BFS(int u)
{
    queue<int>q;
    q.push(u);
    inq[u]=true;
    while(!q.empty())
    {
        u=q.front(); q.pop();
        for(int v=0;v<n;v++)
        {
            if(inq[v]==false && G[u][v]!=INF)
            {
                q.push(v);
                inq[v]=true;
            }
        }        
    }    
} 
void BFSTrave()
{
    for(int u=0;u<n;u++)
    {
        if(inq[u]==false) BFS(q);    
    }    
} 


vector<int>Adj[maxn];
bool vis[maxn];
int n;
void BFS(int u)
{
    queue<int>q;
    q.push(u);
    vis[u]=true;
    while(!q.empty())
    {
        u=q.front(); q.pop();
        for(int i=0;i<Adj[u].size();i++)
        {
            int v=Adj[u][i];
            if(vis[v]==false)
            {
                q.push(v);
                vis[v]=true;
            }
        }
    }
    
}
void BFSTrave()
{
    for(int u=0;u<n;u++)
    if(vis[u]==false) BFS(u);
}



#include<vector>
#include<cstdio>
#include<cstring> 
#include<iostream>
using namespace std;
const int maxn = 1010;
int n,m,L,vis[maxn]={false};
vector<int>Adj[maxn];
struct Pos
{
    int v;
    int layer;
    Pos(int _v,int _layer)
    { 
        v=_v,layer=_layer;
    }
};
void BFS(int u,int &cnt)
{
    queue<Pos>q;
    q.push(Pos(u,0));
    vis[u]=true;
    while(!q.empty())
    {
        Pos pos=q.front(); q.pop();
        int u=pos.v,layer=pos.layer;
        for(int i=0;i<Adj[u].size();i++)
        {
            int v=Adj[u][i];
            if(!vis[v] && layer+1<=L)
            {
                //vis[v]=true;
                //q.push(Pos(v,layer+1));
                //cnt++;
                vis[v]=true;
                cnt++;
                q.push(Pos(v,layer+1));
            }
        }
    }
}
int main(void)
{
    cin>>n>>L;
    for(int i=1;i<=n;i++)
    {
        int num,v;
        cin>>num;
        for(int j=0;j<num;j++) 
        {
            cin>>v;
            Adj[i].push_back(v);    
        }    
    }
    cin >> m;
    for(int i=0;i<m;i++)
    {
        int s;
        cin>>s;
        memset(vis,0,sizeof(vis));
        int cnt=0;
        BFS(s+1,cnt);
        printf("%d
",cnt);
    }
    return 0;
}
测试的数据 
7 3
3 2 3 4
0
2 5 6
2 3 1
2 3 4
1 4
1 5
2 2 6

#include<queue>
#include<vector>
#include<cstring>
#include<cstdio>
using namespace std;
const int MAXV=1000;
struct Node{
    int id,layer;
};
vector<Node>Adj[MAXV];
bool vis[MAXV]={false};
int BFS(int s,int L)
{
    int numForward=0;
    queue<Node>q;
    Node start;
    start.id=s;
    start.layer=0;
    q.push(start);
    vis[s]=true;
    while(!q.empty())
    {
        Node topNode=q.front();
        q.pop();
        int u=topNode.id;
        for(int i=0;i<Adj[u].size();i++)
        {
            Node next=Adj[u][i];
            next.layer=topNode.layer+1;
            if(!vis[next.id] && next.layer<=L)
            {
                q.push(next);
                vis[next.id]=true;
                numForward++;    
            } 
        }
    }
    return numForward;
}
int main(void)
{
    Node user;
    int n,L,numFollow,idFollow;
    scanf("%d%d",&n,&L);
    for(int i=1;i<=n;i++)
    {
        user.id=i;
        scanf("%d",&numFollow);
        for(int j=0;j<numFollow;j++)
        {
            scanf("%d",&idFollow);
            Adj[idFollow].push_back(user);    
        }    
    } 
    int numQuery,s;
    scanf("%d",&numQuery);
    for(int i=0;i<numQuery;i++)
    {
        memset(vis,0,sizeof(vis));
        scanf("%d",&s);
        int numForward=BFS(s,L);
        printf("%d
",numForward);
    }
    return 0;
}