小蓝xlanll

这个屌丝很懒，什么也没留下！

热门标签

【天梯赛历年真题题解】L2

作者：小蓝xlanll | 2024-04-10 15:09:35

踩

【天梯赛历年真题题解】L2

L2-001 紧急救援

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 502;
int num[N];
vector<pair<int,int>>G[N];
int vis[N];
int dis[N];
int path[N];
int Max[N];
int sum[N];
int main()
{ 
    int n,m,s,d;
    cin>>n>>m>>s>>d;
    for(int i=0;i<n;i++)
        cin>>num[i];

    for(int i=0;i<m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        G[u].push_back({v,w});
        G[v].push_back({u,w});        
    }
   
    priority_queue< pair<int,int> ,vector< pair<int,int> >, greater< pair<int,int> > >Q;
    Q.push({0,s});
    memset(dis,0x3f3f3f3f,sizeof(dis));
    dis[s]=0;
    sum[s]=1;
    Max[s]=num[s];
    while(!Q.empty())
    {
        
        int u = Q.top().second;
        Q.pop();
        
        if(vis[u])
            continue;
        vis[u]=1;
        
        for(auto [v,w] : G[u])
        {
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                Q.push({dis[v],v});
                sum[v]=sum[u];
                Max[v]=Max[u]+num[v];
                path[v]=u;
            } 
            else if(dis[v]==dis[u]+w)
            {
                sum[v]+=sum[u];
                if(Max[u]+num[v]>=Max[v])
                {
                    Max[v]=Max[u]+num[v];
                    path[v]=u;
                }
            }
        }
    }
    
    cout<<sum[d]<<" "<<Max[d];
 
    cout<<endl;
    int ss = d;
    stack<int>st;
    while(ss!=s)
    {
        st.push(ss);
        ss=path[ss];
    }
    cout<<s;
    while(!st.empty())
    {
        cout<<" "<<st.top();
        st.pop();
    }
   
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

L2-002 链表去重

#include<bits/stdc++.h>
using namespace std;
struct Node
{
    int next;
    int val;
    Node(int next,int w){
        this->next=next;
        this->val=w;
    }
    Node(){
        
    }
}node[100005],node2[100005],node3[100005];
int vis[100005];
int main()
{
    int head,n;
    cin>>head>>n;
    
    for(int i=0;i<n;i++)
    {
        int u,v,w;
        cin>>u>>w>>v;
        node[u]=Node(v,w);
    }
    memset(vis,0,sizeof(vis));
    int x=head;
    int cnt2=0;
    int cnt3=0;
    while(x!=-1)
    {
        int val=node[x].val;
        if(vis[abs(val)])//
        {
            node3[cnt3].next=x;
            node3[++cnt3]=Node(-1,val);
        }else
        {
            node2[cnt2].next=x;
            node2[++cnt2]=Node(-1,val);
            vis[abs(val)]=1;
        }
        x=node[x].next;
    }
    int per=node2[0].next;
    for(int i=1;i<=cnt2;i++)
    {
       
        printf("%05d %d ",per,node2[i].val);
        if(node2[i].next==-1)
            cout<<-1<<endl;
        else
        {
           printf("%05d\n",node2[i].next);
        }
        per=node2[i].next;
    }
     per=node3[0].next;
    for(int i=1;i<=cnt3;i++)
    {
         printf("%05d %d ",per,node3[i].val);
        if(node3[i].next==-1)
            cout<<-1<<endl;
        else
        {
           printf("%05d\n",node3[i].next);
        }
        per=node3[i].next;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

L2-003 月饼

// //k 
// #include<bits/stdc++.h>
// using namespace std;
// int main()
// {
//     int N,D;
//     cin>>N>>D;
//     int w[10005];
//     int v[10005];
//   //  double bz[100000];
//     pair<double,int> bz[100000];
    
//     for(int i=0;i<N;i++)
//     {
//         cin>>w[i];
//     }
//     for(int i=0;i<N;i++)
//     {
//         cin>>v[i];
//     }
//     for(int i=0;i<N;i++)
//     {
//         bz[i].first=(v[i]*1.0/w[i]);
//         bz[i].second=w[i];
//     }
//     sort(bz,bz+N,[](pair<double,int> n1,pair<double,int> n2){
    	
//     	return n1.first>n2.first;
// 	});
//     double res=0;
//     for(int i=0;i<N;i++)
//     {
//         if(D==0)
//             break;
//         if(bz[i].second<=D)
//         {
//             res+=(bz[i].first*bz[i].second);
//             D-=bz[i].second;
//         }
//         else//
//         {
//             res+=(bz[i].first*D);
//             D=0;
//         }
//     }
//     printf("%.2f",res);
// 	return 0;
// }
#include <bits/stdc++.h>
using namespace std;
struct node
{
    double w,v,x;
};

bool cmp(node a,node b)
{
    return a.x>b.x;
}

int main()
{
    int n,i;
    double d,sum=0;
    struct node a[1010];
    scanf("%d %lf",&n,&d);
    for(i=1;i<=n;i++)
    {
        scanf("%lf",&a[i].w);
    }
    for(i=1;i<=n;i++)
    {
        scanf("%lf",&a[i].v);
    }
    for(i=1;i<=n;i++)
    {
        a[i].x=(1.0*a[i].v)/a[i].w;
    }
    sort(a+1,a+n+1,cmp);
    for(i=1;i<=n;i++)
    {
        if(d>=a[i].w)
        {
            sum+=a[i].v;
            d-=a[i].w;
        }
        else
        {
            sum+=1.0*d*a[i].x;
            break;
        }
    }
    printf("%.2f\n",sum);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

L2-004 这是二叉搜索树吗?


// #include<bits/stdc++.h>
// using namespace std;
// int a[1000000];
// int ok=1;
// vector<int>ans;
// void dfs(int l,int r)
// {
//     if(!ok)
//         return;
//     if(l>r)
//         return;
//     if(l==r)
//     {
//         ans.push_back(a[l]);
//         return ;
//     }
//     int val=a[l];
//     int i;
//     for(i=l+1;i<=r;i++)
//     {
//         if(a[i]>=val)
//            break;
//     }
//     // l+1 i-1
//     // [i,r]
//     for(int j=i;j<=r;j++)
//     {
//         if(a[j]<val)
//         {
//             ok=0;
//             return ;
//         }
//     }
//     dfs(l+1,i-1);
//     dfs(i,r);
//     ans.push_back(val);
// }
// void dfs2(int l,int r)
// {
//     if(!ok)
//         return;
//     if(l>r)
//         return;
//     if(l==r)
//     {
//         ans.push_back(a[l]);
//         return ;
//     }
//     int val=a[l];
//     int i;
//     for(i=l+1;i<=r;i++)
//     {
//         if(a[i]<val)
//            break;
//     }
//     // l+1 i-1
//     // [i,r]
//     for(int j=i;j<=r;j++)
//     {
//         if(a[j]>=val)
//         {
//             ok=0;
//             return ;
//         }
//     }
//     dfs2(l+1,i-1);
//     dfs2(i,r);
//     ans.push_back(val);
// }
// int main()
// {
   
//    int n;
//    cin>>n;
//     for(int i=0;i<n;i++)
//     {
//         cin>>a[i];
//     }
//     if(a[0]>a[1])//g z y
//     {
//         dfs(0,n-1);
//     }
//     else//g y z
//     {
//         dfs2(0,n-1);
//     }
//     if(!ok)
//     {
//         cout<<"NO";
//     }
//     else
//     {
//         cout<<"YES"<<endl;
//         for(int i=0;i<ans.size();i++)
//         {
     
//             if(i==0)
//                 cout<<ans[i];
//             else   
//                 cout<<" "<<ans[i];
//         }
//     }
// 	return 0;
// }


#include<bits/stdc++.h>
using namespace std;
int a[1000000];
int ok=0;
vector<int>ans;
struct Tree
{
    Tree* l;
    Tree* r;
    int val;
    Tree(Tree* l, Tree* r, int val){
        this->l = l;
        this->r = r;
        this->val =val;
    }
    Tree(){
        
    }
};
int judge=0;
// int ok=0;
int Max=-1;
void dfs(Tree *& root,int l,int r)
{
    
    if(l>r)
        return;

    root = new Tree(NULL,NULL,a[l]);
    int i=l+1;
    for(;i<=r;i++)
    {
        if(judge)
        {
            if(a[i]>=a[l])
            break;
        }
        else
        {
              if(a[i]<a[l])
            break;
        }
        
        
    }
    // [l+1,i-1]
    if(judge)
    {
         dfs(root->l,l+1,i-1);
          dfs(root->r,i,r);
    }
    else
    {
         dfs(root->l,i,r);
          dfs(root->r,l+1,i-1);
    }
   
}

void dfs2(Tree *&root)
{
    if(root==NULL)
        return;
    dfs2(root->l);
    dfs2(root->r);
    ans.push_back(root->val);
}

void dfs3(Tree *& root)
{
     if(root==NULL)
        return;
      
    if(ok)
        return;
  
    dfs3(root->l);
    if(root->val<Max)
    {
        ok=1;
        return;
    }
    Max=root->val;
    dfs3(root->r);
   
}
int main()
{
    
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
           cin>>a[i];
    if(n==1)
    {
        cout<< "YES";
        cout<<endl;
        cout<<a[0];
        return 0;
    }
    Tree *root= NULL;
    if(a[0]>a[1])
        judge=1;
     else
         judge=0;
   dfs(root,0,n-1);
    dfs2(root);
    dfs3(root);
    if(ok)
    {
        cout<<"NO"<<endl;
        return 0 ;
    }
    
    cout<<"YES"<<endl;
    cout<<ans[0];
    for(int i=1;i<ans.size();i++)
    {
        cout<<" "<<ans[i];
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229

L2-005 集合相似度


#include<bits/stdc++.h>
using namespace std;
unordered_set<int>G[100];
int main()
{
   int N;   
    cin>>N;
     int res;
     int n;
    for(int i=1;i<=N;i++)
    {
        scanf("%d",&n);
        for(int j=0;j<n;j++)
        {       
            scanf("%d",&res);
            G[i].insert(res);
        }
    } 
    int M;
    cin>>M;
    int x,y;    
    while(M--)//10^2
    {
        scanf("%d %d",&x,&y);
        int cnt=0;
        for(auto i : G[x])
        {     
           if(G[y].count(i))
               cnt++;//都有
        }
        int cn2=G[x].size()+G[y].size()-cnt;
        printf("%.2f%\n",cnt*1.0/cn2*100);
       
    }
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

L2-006 树的遍历


#include<bits/stdc++.h>
using namespace std;
int a[100000];
int b[100000];
struct NODE
{
	int val;
	NODE *l;
	NODE *r;
	NODE(int val,NODE *l,NODE *r)
	{
		this->val=val;
		this->l=l;
		this->r=r;
	 } 
};
//2 3 1 5 7 6 4 
//1 2 3 4 5 6 7
void dfs(NODE *&head,int i,int j,int i2,int j2)
{
    if(i>j||i2>j2)
        return ;
	head=new NODE(a[j],NULL,NULL);
	int k=i2;
	for(;k<=j2;k++)
		if(b[k]==a[j])//找到他 
			break;
	int cnt=k-i2;//前面一共多少个	
	dfs(head->l,i,i+cnt-1,i2,k-1);	
	dfs(head->r,i+cnt,j-1,k+1,j2);
}
int main()
{
   	int N;
   	cin>>N;
   	for(int i=0;i<N;i++) 
   	{
   		cin>>a[i];
	 }
	for(int i=0;i<N;i++)
	{
		cin>>b[i]; 
	}
	NODE *root=NULL;
	dfs(root,0,N-1,0,N-1);
	queue<NODE*>Q;
	Q.push(root);
	vector<int>ans;
	while(!Q.empty())
	{
		NODE *head=Q.front();
		Q.pop();
		ans.push_back(head->val);
		if(head->l!=NULL) Q.push(head->l);
		if(head->r!=NULL) Q.push(head->r); 
	}
	if(ans.size()!=0)
		cout<<ans.front();
	for(int i=1;i<ans.size();i++)
		cout<<" "<<ans[i];
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

L2-007 家庭房产

//编号 x  f[x]=x   

#include<bits/stdc++.h>
using namespace std;
unordered_map<string,string>f;//f[x]=y;
unordered_map<string,int>fc;
unordered_map<string,int>fcmj;
string Find(string x)
{
    if(x==f[x]) return x;
    return f[x]=Find(f[x]);
}
void Bond(string x,string y)
{
    string tx=Find(x);
    string ty=Find(y);
    if(tx!=ty) f[tx]=ty;
}

struct pyq
{
    int num;
    int n;
    string minbh;
    int s;
    //家庭成员的最小编号 家庭人口数 人均房产套数 人均房产面积
    pyq(){
	}
    pyq(string minbh,int num,int n,int s)
    {
       this->minbh=minbh;
        this->n=n;
        this->num=num;
        this->s=s;
    }
};
bool cmp(pyq a1,pyq a2)
{
    double a=a1.s*1.0/a1.num;
    double b=a2.s*1.0/a2.num;
    if(a!=b)
    {
        return a>b;
    }
    else
        return a1.minbh<a2.minbh;
}

int main()
{
   
    int N;
    cin>>N;
    string Node;
    string fa;
    string ma;
    int k;
    f.clear();
//    unordered_map<int,int>
    while(N--)
    {
      //  6666 5551 5552 1 7777 1 100
        cin>>Node>>fa>>ma>>k;
        if(!f.count(Node))
            f[Node]=Node;
         if(!f.count(fa))
            f[fa]=fa;
        if(!f.count(ma))
            f[ma]=ma;
        if(fa!="-1")
          Bond(Node,fa);
        if(ma!="-1")
         Bond(Node,ma);
        for(int i=0;i<k;i++)
        {
            string ch;
            cin>>ch;
            if(!f.count(ch))
                f[ch]=ch;
            Bond(Node,ch);
        }
        cin>>fc[Node]>>fcmj[Node];
    }
    
    //计算有多少朋友圈，每个朋友圈的人 人均房产套数 人均房产面积
    
   unordered_map<string,pyq>vis;
   int sum=0;
   for(auto i : f)//遍历全部朋友圈
   {
	if(i.first=="-1") continue;
	string k=Find(i.first);
      if(!vis.count(k))//新的圈
      {
     	 	sum++;
          vis[k].num=1;
           vis[k].n=fc[i.first];
           vis[k].s=fcmj[i.first];
          vis[k].minbh=i.first;
          
      }
       else//老的圈
       {
           
           vis[k].num++;
           vis[k].n+=fc[i.first];
           vis[k].s+=fcmj[i.first];
           if(i.first<vis[k].minbh)
           {
               vis[k].minbh=i.first;
            }
       }
   }
   cout<<sum<<endl;
    vector<pyq>res;
    for(auto i :vis)
    {
        res.push_back(pyq(i.second.minbh,i.second.num,i.second.n,i.second.s));
    }
   sort(res.begin(),res.end(),cmp);
    for(auto i : res)//家庭成员的最小编号 家庭人口数 人均房产套数 人均房产面积
    {
        cout<<i.minbh<<" "<<i.num<<" ";
        printf("%.3f ",i.n*1.0/i.num);
        printf("%.3f\n",i.s*1.0/i.num);
    }
    
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

L2-008 最长对称子串


#include<bits/stdc++.h>
using namespace std;
int dp[1002][1002];
int main()
{
    string s;
    getline(cin,s);
    int n=s.length();
    int Max=1;
//     for(int k=0;k<2*n-1;k++)
//     {
//        	int i=k/2;
//     	int j=k/2+k%2;
//         while(i>=0&&j<n)
//         {
//             if(s[i]==s[j])  
//             {
//                 i--;
//                 j++;
//             }else break;
//             Max=max(Max,j-i-1);
//         }
//     }
    for(int l=1;l<=n;l++)
    {
        for(int i=0;i<n-l+1;i++)
        {
            int j=i+l-1;
            if(l==1)
                dp[i][j]=1;
            else if(l==2)
            {
                if(s[i]==s[j])
                    dp[i][j]=1;
                
            } else
                dp[i][j]=(dp[i+1][j-1]&&(s[i]==s[j]));
            
            if(dp[i][j])
                Max=l;
        }
    }
    cout<<Max;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

L2-009 抢红包

#include<bits/stdc++.h>
using namespace std;
struct node
{
    int num;
    double s;
    int n;
    node(){}
    node(int num,int n,double s){
        this->num=num;
        this->s=s;
        this->n=n;
    }
    
};
bool cmp(node n1,node n2)
{//如果收入金额有并列，则按抢到红包的个数递减输出；如果还有并列，则按个人编号递增输出。
    if(n1.s!=n2.s)
    {
        return n1.s>n2.s;
    }
    else if(n1.n!=n2.n)
    {
        return n1.n>n2.n;       
    }
    else{
        return n1.num<n2.num;
    }
        
}
int main()
{
   int N;
    cin>>N;
    unordered_map<int,pair<int,int>>vis;
    for(int i=1;i<=N;i++)
    {
        int n;
        int sum=0;
        cin>>n;
        while(n--)
        {
           int je;
           int bh;
            cin>>bh>>je;
            sum+=je;
            if(!vis.count(bh))
            {
                vis[bh].first=je;
                vis[bh].second=1;
            }
            else
            {
                vis[bh].first+=je;
                vis[bh].second++;
            }
        }
        if(!vis.count(i))
        {
            vis[i].second=0;
            vis[i].first=-sum;
        }
        else
        {
            vis[i].first-=sum;
        }
    }
    vector<node>ans;
    for(auto i :vis)
    {     
        ans.push_back(node(i.first,i.second.second,i.second.first*1.0/100));
    }
    sort(ans.begin(),ans.end(),cmp);
    for(auto i :ans)
    {
        cout<<i.num<<" ";
		printf("%.2f\n",i.s);
     }
                      
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

L2-010 排座位

// #include<bits/stdc++.h>
// using namespace std;
// int Find(int x,int *f)
// {
//     if(x==f[x]) return x;
//     else return f[x]=Find(f[x],f);
// }
// void Bond(int x,int y,int *f)
// {
//     int tx=Find(x,f);
//     int ty=Find(y,f);
//     f[tx]=ty;
// }
// int f[100000];
// int df[100000];
// int main()
// {
//     /*如果两位宾客之间是朋友，且没有敌对关系，则输出No problem； 
//     如果他们之间并不是朋友，但也不敌对，则输出OK；
//     如果他们之间有敌对，然而也有共同的朋友，则输出OK but...；
//     如果他们之间只有敌对关系，则输出No way。*/
//     int N,M,K;
//     cin>>N>>M>>K;
//     int zjdd[200][200]={0};
//     for(int i=1;i<=N;i++)
//     {
//         f[i]=i;
//         df[i]=i;
//     }
//     while(M--)
//     {
//         int x,y,ok;
//         cin>>x>>y>>ok;
//         if(ok==1)//朋友
//         {
//             Bond(x,y,f);
//          }
//         else//敌人
//         {
//             Bond(x,y,df);
//             zjdd[x][y]=1;
//             zjdd[y][x]=1;
//         }
//     }
//      /*如果两位宾客之间是朋友，且没有敌对关系，则输出No problem； 
//     如果他们之间并不是朋友，但也不敌对，则输出OK；
//     如果他们之间有敌对，然而也有共同的朋友，则输出OK but...；
//     如果他们之间只有敌对关系，则输出No way。*/
//     while(K--)
//     {
//         int x,y;
//         cin>>x>>y;
//         if(Find(x,f)==Find(y,f)&&zjdd[x][y]==0)
//         {
//             cout<<"No problem"<<endl;
//             continue;
//         }
//         if(Find(x,f)!=Find(y,f)&&zjdd[x][y]==0) 
//         {
//             cout<<"OK"<<endl;
//             continue;
//         }
//        if(Find(x,f)==Find(y,f)&&Find(x,df)==Find(y,df))
//        {
//            cout<<"OK but..."<<endl;
//            continue;
//        }
//        if(zjdd[x][y]==1)
//        {
//            cout<<"No way"<<endl;
//            continue;
//        }
//     }
// 	return 0;
// }

#include<bits/stdc++.h>
using namespace std;
int f[200][2];
int Find(int x,int i)
{
    if(x==f[x][i])
        return x;
    return f[x][i] = Find(f[x][i],i);
}
void Band(int x,int y,int i)
{
    int tx = Find(x,i);
    int ty = Find(y,i);
    if(tx!=ty)
    {
        f[tx][i]=ty;
    }
}

int main()
{
    
    int N,M,K;
    cin>>N>>M>>K;
    for(int i=1;i<=N;i++)
    {
        f[i][0]=f[i][1]=i;       
    }
    while(M--)
    {
        int x,y,ok;
        cin>>x>>y>>ok;
        if(ok==1)//朋友
        {
            Band(x,y,1);
         }
        else//敌人
        {
            Band(x,y,0);
        }
    }
    while(K--)
    {
        int u,v;
        cin>>u>>v;
        int p1 = (Find(u,1)==Find(v,1));
        int p2 = (Find(u,0)==Find(v,0));
        
        if(p1&&!p2)
            cout<<"No problem";
        else if(!p1&&!p2)
            cout<<"OK";
        else if(p1&&p2)
            cout<<"OK but...";
        else 
            cout<<"No way";
        cout<<endl;
    }  
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

L2-011 玩转二叉树


#include<bits/stdc++.h>
using namespace std;
int a[100000];
int b[100000];
struct NODE
{
	int val;
	NODE *l;
	NODE *r;
	NODE(int val,NODE *l,NODE *r)
	{
		this->val=val;
		this->l=l;
		this->r=r;
	 } 
};
//
//4 1 3 2 6 5 7  q //a
//1 2 3 4 5 6 7 zho b
void dfs(NODE *&head,int i,int j,int i2,int j2)
{
	head=new NODE(a[i],NULL,NULL);
	int k=i2;
	for(;k<=j2;k++)
	{
		if(b[k]==a[i])//找到他  a是前 
		{
			break;
		}
	}
	int cnt=k-i2;//前面一共多少个
	if(k-1>=i2)//有左边 
		dfs(head->l,i+1,i+cnt,i2,k-1);
	if(k+1<=j2)//有右边 
		dfs(head->r,i+cnt+1,j,k+1,j2);
}
int main()
{
   	int N;
   	cin>>N;
   	for(int i=0;i<N;i++) 
   	{
   		cin>>b[i]; //中 
	 }
	for(int i=0;i<N;i++)
	{
		cin>>a[i];//前 
	}
	NODE *root=NULL;
	dfs(root,0,N-1,0,N-1);
	queue<NODE*>Q;
	Q.push(root);
	vector<int>ans;
	while(!Q.empty())
	{
		NODE *head=Q.front();
		Q.pop();
		ans.push_back(head->val);
		if(head->r!=NULL) Q.push(head->r);
		if(head->l!=NULL) Q.push(head->l); 
	}
	if(ans.size()!=0)
		cout<<ans[0];
	for(int i=1;i<ans.size();i++)
		cout<<" "<<ans[i];
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

L2-012 关于堆的判断


#include<bits/stdc++.h>
using namespace std;
int a[100000];
int b[100000];
struct NODE
{
	int val;
	NODE *l;
	NODE *r;
	NODE(int val,NODE *l,NODE *r)
	{
		this->val=val;
		this->l=l;
		this->r=r;
	 } 
};
//
//4 1 3 2 6 5 7  q //a
//1 2 3 4 5 6 7 zho b
void dfs(NODE *&head,int i,int j,int i2,int j2)
{
	head=new NODE(a[i],NULL,NULL);
	int k=i2;
	for(;k<=j2;k++)
	{
		if(b[k]==a[i])//找到他  a是前 
		{
			break;
		}
	}
	int cnt=k-i2;//前面一共多少个
	if(k-1>=i2)//有左边 
		dfs(head->l,i+1,i+cnt,i2,k-1);
	if(k+1<=j2)//有右边 
		dfs(head->r,i+cnt+1,j,k+1,j2);
}
int main()
{
   	int N;
   	cin>>N;
   	for(int i=0;i<N;i++) 
   	{
   		cin>>b[i]; //中 
	 }
	for(int i=0;i<N;i++)
	{
		cin>>a[i];//前 
	}
	NODE *root=NULL;
	dfs(root,0,N-1,0,N-1);
	queue<NODE*>Q;
	Q.push(root);
	vector<int>ans;
	while(!Q.empty())
	{
		NODE *head=Q.front();
		Q.pop();
		ans.push_back(head->val);
		if(head->r!=NULL) Q.push(head->r);
		if(head->l!=NULL) Q.push(head->l); 
	}
	if(ans.size()!=0)
		cout<<ans[0];
	for(int i=1;i<ans.size();i++)
		cout<<" "<<ans[i];
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

L2-013 红色警报


#include<bits/stdc++.h>
using namespace std;
int a[100000];
int b[100000];
struct NODE
{
	int val;
	NODE *l;
	NODE *r;
	NODE(int val,NODE *l,NODE *r)
	{
		this->val=val;
		this->l=l;
		this->r=r;
	 } 
};
//
//4 1 3 2 6 5 7  q //a
//1 2 3 4 5 6 7 zho b
void dfs(NODE *&head,int i,int j,int i2,int j2)
{
	head=new NODE(a[i],NULL,NULL);
	int k=i2;
	for(;k<=j2;k++)
	{
		if(b[k]==a[i])//找到他  a是前 
		{
			break;
		}
	}
	int cnt=k-i2;//前面一共多少个
	if(k-1>=i2)//有左边 
		dfs(head->l,i+1,i+cnt,i2,k-1);
	if(k+1<=j2)//有右边 
		dfs(head->r,i+cnt+1,j,k+1,j2);
}
int main()
{
   	int N;
   	cin>>N;
   	for(int i=0;i<N;i++) 
   	{
   		cin>>b[i]; //中 
	 }
	for(int i=0;i<N;i++)
	{
		cin>>a[i];//前 
	}
	NODE *root=NULL;
	dfs(root,0,N-1,0,N-1);
	queue<NODE*>Q;
	Q.push(root);
	vector<int>ans;
	while(!Q.empty())
	{
		NODE *head=Q.front();
		Q.pop();
		ans.push_back(head->val);
		if(head->r!=NULL) Q.push(head->r);
		if(head->l!=NULL) Q.push(head->l); 
	}
	if(ans.size()!=0)
		cout<<ans[0];
	for(int i=1;i<ans.size();i++)
		cout<<" "<<ans[i];
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

L2-014 列车调度

#include<bits/stdc++.h>
using namespace std;
int main()
{
		
    int N;
    cin>>N;
    set<int>vis;
    for(int i=0;i<N;i++)
    {
        int m;
        cin>>m;
        auto it=vis.lower_bound(m);//比大于或者等于他的第一个数
       if(it!=vis.end())
       {
           vis.erase(it);
       }
        vis.insert(m);
    }
    cout<<vis.size();
    return 0;
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

L2-015 互评成绩

#include<bits/stdc++.h>
using namespace std;
int main()
{
	
    int N,M,K;
    cin>>N>>K>>M;
    vector<double>ans;
    while(N--)
    {
       double Max=-1;
        double Min=1000;
        double sum=0;
        double cj;
      for(int i=0;i<K;i++)
      {
          cin>>cj;
          Max=max(Max,cj);
          Min=min(Min,cj);
          sum+=cj;
      }
        double zjcj=(sum-Max-Min)*1.0/(K-2);
        ans.push_back(zjcj);
    }
    sort(ans.begin(),ans.end());
    int n=ans.size()-M;
  //  cout<<n<<"  ";
    if(n==-1)
        n=0;
    for(int i=n;i<ans.size()-1;i++)
       printf("%.3f ",ans[i]);
    printf("%.3f\n",ans[ans.size()-1]);
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

L2-016 愿天下有情人都是失散多年的兄妹

#include<bits/stdc++.h>
using namespace std;
unordered_map<string,vector<string> >G;
unordered_map<string,int>Xb;
unordered_map<string,int>vis;
int dfs(string x,int k)
{
    if(k==5)
        return 0;
    if(vis[x]==1)
        return 1;
    if(!G.count(x)) return 0;
    for(int i=0;i<G[x].size();i++)
    {
       
        if(dfs(G[x][i],k+1)==1)
            return 1;
    }
    return 0;
}
void dfs2(string x,int k)
{
    if(k==5)
        return ;
      vis[x]=1;
    if(!G.count(x)) return ;
    for(int i=0;i<G[x].size();i++)
    {
        dfs2(G[x][i],k+1);
    }
    return ;
}
int main()
{
    int N;
    string node;
    string fa;
    string ma;
    string xb;
    cin>>N;
    while(N--)
    {
        cin>>node>>xb>>fa>>ma;
        if(fa!="-1")
        {
            Xb[fa]=1;
            G[node].push_back(fa); 
        }
             
        if(ma!="-1")
        {
             G[node].push_back(ma); 
            Xb[ma]=-1;
        }
        if(xb=="M")
            Xb[node]=1;
        if(xb=="F")
            Xb[node]=-1;       
    }
    int K;
    cin>>K;
    string s1;
    string s2;
    while(K--)
    {
        cin>>s1>>s2;
        if(Xb[s1]==Xb[s2])
        {
            cout<<"Never Mind"<<endl;
            continue;
        }
        vis.clear();
        dfs2(s1,0);
        int ok=dfs(s2,0);
        if(ok==1)
        {
            cout<<"No"<<endl;
        }
        else
        {
            cout<<"Yes"<<endl;
        }
        
    }
    
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

L2-017 人以群分

//要求两类人群的规模尽可能接近，而他们的总活跃度差距尽可能拉开
#include<bits/stdc++.h>
using namespace std;
int main()
{
    int N;
    cin>>N;
    vector<int>ans;
    int sum2=0;
    for(int i=0;i<N;i++)
    {
        int k;
        cin>>k;
        ans.push_back(k);
        sum2+=k;
    }
    sort(ans.begin(),ans.end());
    int k=ans.size()/2;
    int sum=0;
    for(int i=0;i<k;i++)
       sum+=ans[i];
    int diff=abs(sum2-2*sum);
    cout<<"Outgoing #: "<<ans.size()-k<<endl;
    cout<<"Introverted #: "<<k<<endl;
    cout<<"Diff = "<<diff<<endl;

 
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

L2-018 多项式A除以B

L2-019 悄悄关注

#include<bits/stdc++.h>
using namespace std;
int main()
{
    //全部标记
    //算平均 并把没有出现的人加入ve 
    vector<pair<string,int>>ans;
    unordered_map<string,int>vis;
    int N;
    cin>>N;
    while(N--)
    {
        string s;
        cin>>s;
        vis[s]=1;
    }
    
    int M;
    cin>>M;
    int MM=M;
    int sum=0;
    int k;
    string num;
    while(M--)
    {
        cin>>num>>k;
        sum+=k;
        if(!vis.count(num)) ans.push_back({num,k});
    }
    double pjs=sum*1.0/MM;
 //   cout<<pjs<<"  ";
    sort(ans.begin(),ans.end());
    int ok=0;
    for(auto i : ans)
    {
        if(i.second*1.0>pjs)
        {
            ok=1;
            cout<<i.first<<endl;
        }
    }
    if(ok==0)
          cout<<"Bing Mei You";
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

L2-020 功夫传人

#include<bits/stdc++.h>
using namespace std;
int n;
double z,r;
vector<int>G[100005];
double a[100005]={0};
double ans=0.0;
void dfs(int u,double res)
{
     if(a[u]!=0)//得到纸
    {
        ans+=res*a[u];
        return;
    }
       
    for(auto v : G[u])
    {
       
         dfs(v,res*(1-r/100));
    }
}
int main()
{
   cin>>n>>z>>r;
   for(int i=0;i<n;i++)
   {
       int x;
       cin>>x;
       if(x==0)//
       {
           double w;
           cin>>w;
           a[i]=w;
       }
       for(int j=0;j<x;j++)
       {
           int y;
           cin>>y;
           G[i].push_back(y);
       }
   }
    dfs(0,z);
    printf("%.f",ans-0.5);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

L2-021 点赞狂魔

#include<bits/stdc++.h>
using namespace std;
struct Node
{
    string s;
    int ps;
    int zps;
    Node(){}
    Node(string s,int ps,int zps)
    {
        this->s=s;
        this->ps=ps;
        this->zps==zps;                    
    }
    bool operator < (Node &n1)
    {
        if(this->s!=n1.s)
        {
            return this->ps>n1.ps;
        }
        else
        {
            return this->zps<n1.zps;
        }
    }
};
int main()
{
    int N;
    cin>>N;
    string s;
    int k;
    int bh;
    unordered_map<string,pair<int,int>>vis;//总票和票不同树
    unordered_map<int,int>ok;
    while(N--)
    {
        cin>>s>>k;
        vis[s].second=k;//总
        vis[s].first=0;
       ok.clear();
        for(int i=0;i<k;i++)
        {
            cin>>bh;
            if(!ok.count(bh))
            {
               vis[s].first++;
                ok[bh]=1;
                
            }
        }
    }
    vector<Node>res;
    for(auto i : vis)
    {
        res.push_back(Node(i.first,i.second.first,i.second.second));
    }
    sort(res.begin(),res.end());
    int nn=res.size();
    if(nn==0)
    {
        cout<<"- - -";
    }else
    {
        cout<<res[0].s;
        int nnn=nn>=3?3:nn;
         for(int i=1;i<nnn;i++)
        {
            cout<<' '<<res[i].s;
        }
        if(nn<3)
        {
            for(int i=0;i<3-nn;i++)
            {
                cout<<' '<<'-';
            }
        }
    }
 
	return 0;
    
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

L2-022 重排链表

#include<bits/stdc++.h>
using namespace std;
struct Node
{
  int val;
  int next;
}G[1000000];
// 1 2 3 
// 1 2 3 4
int main()
{
    int head;
    int N;
    cin>>head>>N;  
    int root;
    int next;
    int val;
    unordered_map<int,int>vis;
    for(int i=0;i<N;i++)
    {
        cin>>root>>val>>next;
        G[root].next=next;
        G[root].val=val;
    }
    int cnt=0;
    int data[1000000];
    for(int i=head;i!=-1;i=G[i].next)
    {
        data[cnt++]=i;
    }
    cnt--;
    vector<int>ans;
    int i=0;
    int j=cnt;
    while(1)
    {
        //1 2 3 4  5 6
       // i   j
       // 1  2
   //     i  j
        ans.push_back(data[j]);
        if(i==j) break;
        j--;
        ans.push_back(data[i]);
        i++;
        if(i-j==1)
          break;
        
    }
    for(int i=0;i<ans.size();i++)
    {
        if(i==0)
            printf("%05d %d ",ans[i],G[ans[i]].val);          
        else 
            printf("%05d\n%05d %d ",ans[i],ans[i],G[ans[i]].val);
    }
    cout<<-1;
	return 0;
    
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

L2-023 图着色问题

#include<bits/stdc++.h>
using namespace std;
vector<int>G[502];
int a[502];
int vis[502];
int ok2=0;
void dfs(int u)
{
    if(ok2)
       return;
    vis[u]=1;
    for(auto v : G[u])
    {
        if(!vis[v])
        {
            dfs(v);
        } else if(a[v]==a[u])
        {
            ok2=1;
            return ;
        }
        
    }
}
int main()
{
    int n,m,k;
    cin>>n>>m>>k;
    while(m--)
    {
        int x,y;
        cin>>x>>y;
        G[x].push_back(y);
        G[y].push_back(x);
      
    }
    int t;
    cin>>t;
    while(t--)
    {
        int cnt=0;
        ok2=0;
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            if(!vis[a[i]])
            { vis[a[i]]=1;
             cnt++;
            };
         }
       if(cnt!=k)
       {
           cout<<"No"<<endl;
           continue;
       }
       memset(vis,0,sizeof(vis));
       for(int i=1;i<=n;i++)
       {
           if(!vis[i])
               dfs(i);
       }
        if(!ok2)
        {
            cout<<"Yes"<<endl;
        }
        else
        {
            cout<<"No"<<endl;
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

L2-024 部落

#include<bits/stdc++.h>
using namespace std;
int f[1000000];
int Find(int x)//查找它的祖先是谁 
{
	if(f[x]==x)
		return x;
	else
		return f[x]=Find(f[x]);
}
void Ban(int x,int y)//合并 
{
	int tx=Find(x);
	int ty=Find(y);
	if(tx!=ty)
	{
		f[ty]=tx;
	}
}
int main()
{
    int N;
    cin>>N;
    for(int i=0;i<=10000;i++)
        f[i]=i;
    int K;
    unordered_map<int,int>viss;
    set<int>res;
    while(N--)
    {
        cin>>K;
        int num;
        vector<int>ans;
        for(int i=0;i<K;i++)
        {
            cin>>num;
            viss[num]=1;
            ans.push_back(num);
            res.insert(num);
        }
        if(K>1)
            for(int i=0;i<ans.size()-1;i++)
            {
                 Ban(ans[i],ans[i+1]);
            }
    }
    set<int>rres;
    for(int i=1;i<=10000;i++)
    {
        if(viss.count(i))
        {
            rres.insert(Find(i));
        }
    }
    cout<<res.size()<<" "<<rres.size()<<endl;
    int M;
    cin>>M;
    while(M--)
    {
        int x,y;
        cin>>x>>y;
        if(Find(x)==Find(y))
             cout<<'Y'<<endl;
        else
            cout<<'N'<<endl;
    }
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

L2-025 分而治之


#include<bits/stdc++.h>
using namespace std;
int f[100000];
int Find(int x)//查找它的祖先是谁 
{
	if(f[x]==x)
		return x;
	else
		return f[x]=Find(f[x]);
}
void Ban(int x,int y)//合并 
{
	int tx=Find(x);
	int ty=Find(y);
	if(tx!=ty)
	{
		f[ty]=tx;
	}
}
struct Node
{
    int u;
    int v;
    
}G[100000];
int main()
{
    int N,E;
    cin>>N>>E;
    for(int i=1;i<=E;i++)
    {
        int x,y;
        cin>>x>>y;
        G[i].u=x;
        G[i].v=y;
    //    Ban(x,y);
    }
    int M;
    cin>>M;
    int gz[100000];
    while(M--)
    {
        int K;
        cin>>K;
        int x;
        memset(gz,0,sizeof(gz));
        for(int i=1;i<=N;i++)
            f[i]=i;           
        for(int i=0;i<K;i++)
        {
            cin>>x;
            gz[x]=-1;
        }       
        for(int i=1;i<=E;i++)
        {
            if(gz[G[i].u]!=-1&&gz[G[i].v]!=-1)
            {
                Ban(G[i].u,G[i].v);
            }
        }
        unordered_set<int>res;
            
        for(int i=1;i<=N;i++)//朋友圈个数
        {
        //    if(B)
            res.insert(Find(i));
        }
        //cout<<res.size()<<"   ";
        if(res.size()==N)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

L2-026 小字辈

#include<bits/stdc++.h>
using namespace std;
vector<int>G[1000000];
int d=0;
int vis[1000000];//
int Maxd=0;
void dfs(int k,int u)
{
    
    vis[u]=k;
    Maxd=max(Maxd,k);
    for(int i=0;i<G[u].size();i++)
    {
        dfs(k+1,G[u][i]);
    }
}
int main()
{
    //建图 输出最深度 深度为最s的那一层
    int N;
    cin>>N;
    for(int i=1;i<=N;i++)
    {
        int x;
        cin>>x;
        if(x!=-1)
            G[x].push_back(i);
        else
            G[100005].push_back(i);
    }
    dfs(0,100005);
    cout<<Maxd<<endl;
    vector<int>ans;
    for(int i=1;i<=N;i++)
        if(vis[i]==Maxd)
            ans.push_back(i);
   sort(ans.begin(),ans.end());
   if(ans.size()>=1)
       cout<<ans[0];
    for(int i=1;i<ans.size();i++)
    {
        cout<<" "<<ans[i];
    }
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

L2-027 名人堂与代金券

//成绩相同的学生享有并列的排名，排名并列时，按账号的字母序升序输出。
#include<bits/stdc++.h>
using namespace std;
pair<string,int>p[10005];
int main()
{
    int N,G,k;
    cin>>N>>G>>k;
    int ans=0;
    for(int i=0;i<N;i++)
    {
        cin>>p[i].first>>p[i].second;
        if(p[i].second>=G)
        {
            ans+=50;
        }else if(p[i].second>=60)
        {
            ans+=20;
        }
    }
    sort(p,p+N,[](pair<string,int>n1,pair<string,int>n2){
        if(n1.second!=n2.second)
            return n1.second>n2.second;
        else        
            return n1.first<=n2.first;
    });
    int cnt=0;
    int per=-1;
    cout<<ans<<endl;
    for(int i=0;i<N;i++)
    {
        if(per==p[i].second)
        {
            cout<<cnt<<" "<<p[i].first<<" "<<p[i].second<<endl;
        }
        else
        {
            cnt=i+1;
            if(cnt<=k)
            {
                 cout<<cnt<<" "<<p[i].first<<" "<<p[i].second<<endl;
            }
            else
              break;
           
         }
        per=p[i].second;
    }
    return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

L2-028 秀恩爱分得快

#include<bits/stdc++.h>
using namespace std;
double a[1005];
double c[1005];
vector<int>G[1001][2];
bool ok[1005][1005];
int vis[1005][1005];
int n,m;
vector<int> f(string s)
{
    int num=atoi(s.data());
    int type;
    if(s[0]=='-')//女
        type=1,num=-num;
    else//男的
        type=0;
    double Max=0;
    memset(c,0,sizeof(c));
    for(int i=0;i<m;i++)
    {
        if(!vis[i][num])//他在不在这个照片里面  
            continue;
        for(auto num : G[i][type])//女
        {
            c[num]+=a[i];
            Max=max(Max,c[num]);
        }
    }
    vector<int>ans;
    for(int i=0;i<n;i++)
        if(Max==c[i])
        {           
            ok[i][num]=1;
            ans.push_back(i);
        }
    sort(ans.begin(),ans.end());
    return ans;
}
int main()
{
    
    cin>>n>>m;
    memset(vis,0,sizeof(vis));
    memset(ok,false,sizeof(ok));
    for(int i=0;i<m;i++)//1000
    {
        int k;
        cin>>k;
        a[i]=1.0/k;
        for(int j=0;j<k;j++)//500
        {
            string s;
            cin>>s;
            int num=atoi(s.data());
            if(num<0)
                num=-num;
            vis[i][num]=1;
            if(s[0]=='-')//女
               G[i][0].push_back(num);     
           else
               G[i][1].push_back(num);
        }
    }//500*500=150000000
    string x,y;
    cin>>x>>y;
    vector<int>ans1=f(x);
    vector<int>ans2=f(y);
    int num=abs(atoi(x.data()));
    int num2=abs(atoi(y.data()));
    if(ok[num][num2]&&ok[num2][num])
        cout<<x<<" "<<y<<endl;
    else
    {
        for(auto num : ans1)
        {
            if(x[0]=='-')
            {
                cout<<x<<" "<<num<<endl;
            }
            else
            {
                cout<<x<<" -"<<num<<endl;
            }
        }
        for(auto num : ans2)
        {
            if(y[0]=='-')
            {
                cout<<y<<" "<<num<<endl;              
            }
            else
            {
                cout<<y<<" -"<<num<<endl;
            }
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

L2-029 特立独行的幸福

//通过游戏里不同的操作或选择可以从某个剧情点去往另外一个剧情点
#include<bits/stdc++.h>
using namespace std;
vector<int>ans;
vector<int>res(100001);
int ss[100001]={0};
int ok(int u)
{
    unordered_map<int,int>re;
    int k=u;
    re[u]=1;
    while(1)
    {
        int v=k;
        k=0;
        while(v>0)
        {
            k=k+(v%10)*(v%10);
            v/=10;
        }
        if(re[k]==1)
            return -1;
        re[k]=1;
        ans.push_back(k);
        if(k==1)
        {
            res[u]=ans.size();
           return 1;          
        }
    } 
}
void f()
{
    int n=10001;
    for(int i=2;i<=sqrt(n+0.5);i++)
    {
        if(ss[i]==1)//不是素数
            continue;
        for(int j=i*i;j<=n;j+=i)
        {
            ss[j]=1;//不是素数;
        }
    }
}
int main()
{
		
    int x,y;
    cin>>x>>y;
    int vis[100001]={0};
    
    f();
    
    int judge=0;
    
    for(int i=x;i<=y;i++)//从推出去的所有数都不是 
    {
        if(vis[i]==1)
            continue;
        ans.clear();
       // cout<<ok(i)<<" ";
		if(ok(i)==-1)//这个数是循环
            vis[i]=1;//
       for(int i=0;i<ans.size();i++)
            vis[ans[i]]=1;//全部不是特别幸福
        
    }
    
  for(int i=x;i<=y;i++)
  {
  		//cout<<vis[i]<<" ";
      if(vis[i]==0)
      {
          judge=1;
          if(ss[i]==0)
                cout<<i<<" "<<res[i]*2<<endl;
            else
               cout<<i<<" "<<res[i]<<endl;
      }
  }
    if(judge==0)
        cout<<"SAD";
    return 0;
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

L2-030 冰岛人

L2-031 深入虎穴

#include<bits/stdc++.h>
using namespace std;
vector<int>G[100005];
int vis2[100005]={0};
int Max=-1;
int Maxnum=2;
void dfs(int u,int k)
{
  
    for(int i=0;i<G[u].size();i++)
    {
       if(G[u][i]==0)
       {
           if(Max<k)
           {
               Max=k;
               Maxnum=u;
           }
        }
        else dfs(G[u][i],k+1);
    }
}
int main()
{
    int N;
    cin>>N;
    for(int i=1;i<=N;i++)
    {
        int K;
        cin>>K;
        if(K==0)
            G[i].push_back(K);
       else for(int j=0;j<K;j++)
        {
            int x;
            cin>>x;
            G[i].push_back(x);
            vis2[x]=1;
        }       
    }
    
    for(int i=1;i<=N;i++)
        if(vis2[i]==0)
              dfs(i,0);
    cout<<Maxnum;
    
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

L2-032 彩虹瓶

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int N,M,K;
    cin>>N>>M>>K;
    
    for(int i=0;i<K;i++)
    {
        stack<int>sk;
        while(!sk.empty()) sk.pop();
        int x;
        int cnt=1;//需要的
        int ok=0;
        for(int i=1;i<=N;i++)
        {
            cin>>x;
            if(ok==1)
                continue;
            while(!sk.empty()&&sk.top()==cnt)
            {
                cnt++;
                sk.pop();
            }
            if(cnt==x)
            {
                cnt++;
                 while(!sk.empty()&&sk.top()==cnt)
                {
                    cnt++;
                    sk.pop();
                }
            }
            else
            {
                sk.push(x);
            }
            if(sk.size()>M)
            {
             //   cout<<"NO"<<endl;
                ok=1;
            }
        }
        if(ok==1||cnt<=N)     
            cout<<"NO"<<endl;
        else
            cout<<"YES"<<endl;
        
    }
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

L2-033 简单计算器

#include<bits/stdc++.h>
using namespace std;
int main()
{
    stack<int>s;
    stack<char>fh;
    int N;
    cin>>N;
    int num;
    for(int i=0;i<N;i++)
    {
        cin>>num;
        s.push(num);
    }
    char c;
    for(int i=0;i<N-1;i++)
    {
        cin>>c;
        fh.push(c);
    }
    while(!fh.empty())
    {
        int a1=s.top();
        s.pop();
        int a2=s.top();
        s.pop();
        char cc=fh.top();
        fh.pop();
        if(cc=='+')
        {
            s.push(a1+a2);
        }else if(cc=='-')
        {
            s.push(a2-a1);
        }else if(cc=='*')
        {
            s.push(a2*a1);
        }else{
            if(a1==0)
            {
                cout<<"ERROR: "<<a2<<"/0"<<endl;
                return 0;
            }
            else
                s.push(a2/a1);
        }
    }
    cout<<s.top();
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

L2-034 口罩发放

L2-035 完全二叉树的层序遍历

#include<bits/stdc++.h>
using namespace std;
int a[100];
struct N
{
    int val;
    int l;
    int r;
}Node[1005];
int cnt=-1;
int dfs(int l,int r,int k)
{
    if(l>r)
        return -1;
    int i=(r-l)/2;
    cnt++;
    int t=cnt;
    Node[t].l=dfs(l,r-i-1,k-1);
    Node[t].r=dfs(r-i,r-1,k-1);
    Node[t].val=a[r];
    return t;
}
int n;
void dfs2(int i)
{
    if(i>n)
      return ;
    dfs2(2*i);
    dfs2(2*i+1);
    cin>>a[i];
}
int main()
{
    
    cin>>n;
    dfs2(1);
    for(int i=1;i<=n;i++)
    {
        if(i==1)
            cout<<a[i];
        else
           cout<<" "<<a[i];
    }
//     for(int i=0;i<n;i++)
//         cin>>a[i];
//     int k=log2(n+1);
//     dfs(0,n-1,k);
//     queue<int>Q;
//     vector<int>ans;
//     Q.push(0);
//     while(!Q.empty())
//     {
//         int u=Q.front();
//         ans.push_back(Node[u].val);
//         Q.pop();
//         if(Node[u].l!=-1)
//         {
//             Q.push(Node[u].l);
//         }
//         if(Node[u].r!=-1)
//         {
//             Q.push(Node[u].r);
//         }
//     }
//     for(int i=0;i<ans.size();i++)
//     {
//         if(i==0)
//             cout<<ans[i];
//         else    
//             cout<<" "<<ans[i];
//     }
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

L2-036 网红点打卡攻略

#include<bits/stdc++.h>
using namespace std;
int main()
{
     int N,M;
    cin>>N>>M;
    int G[300][300]={0};
    while(M--)
    {
        int x,y,w;
        cin>>x>>y>>w;
        G[x][y]=w;
        G[y][x]=w;
    }
    int K;
    cin>>K;
    int Maxsum=INT_MAX;
    int Maxsum_num;
    int l=0;
    
    for(int i=1;i<=K;i++)
    {
        int n;
        cin>>n;
        unordered_map<int,int>vis;
        vector<int>ans(n+2);
        ans[0]=0;
        ans[n+1]=0;
        int ok=1;
        int sum=0;
        for(int j=1;j<=n;j++)
        {
            int u;
            cin>>u;
            if(ok==0)
                continue ;
            if(vis.count(u))//重复了
            {
                ok=0;
            }
            else
            {
                vis[u]=1;
                if(!G[u][ans[j-1]])//没有边
                {
                    ok=0;
                }
                else
                {
                    sum+=G[u][ans[j-1]];
                    ans[j]=u;
                }
            }
        }
         if(ok==0||vis.size()<N)
             continue ;
        if(G[ans[n]][ans[n+1]]!=0)
        {
            sum+=G[ans[n]][ans[n+1]];
        }
        else
            continue ;
        l++;
      // cout<<i<<" ";
        if(sum<Maxsum)
        {
            Maxsum=sum;
            Maxsum_num=i;
        }
        
    }
    cout<<l<<endl;
    cout<<Maxsum_num<<" "<<Maxsum;
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

L2-037 包装机

/*一种特殊情况是，因为筐的容量是有限的，当筐已经满了，但仍然有某条轨道的按钮被按下时，系统应强制启动 0 号键，先从筐里抓出一件物品，再将对应轨道的物品推落。
//
此外，如果轨道已经空了，再按对应的按钮不会发生任何事；
同样的，如果筐是空的，按 0 号按钮也不会发生任何事。*/
//定义N个stack  n// vector // stack sk
#include<bits/stdc++.h>
using namespace std;
int main()
{
    
    int N,M,S;
    cin>>N>>M>>S;
   queue<int>Q[N+1];
    stack<int>sk;
    vector<int>ans;
    vector<int>temp;
    char c;
    for(int i=1;i<=N;i++)
    {
        for(int j=0;j<M;j++)
        {
            cin>>c;
            Q[i].push(c);
        }      
    }
    int num;
    while(1)
    {
        cin>>num;
        if(num==-1)
            break;
        if(num==0)
        {
            if(sk.size()==0)
                 continue;
            else
            {
               int wp= sk.top();
                sk.pop();
                ans.push_back(wp);
            }
            continue;
        }
        else//按了其他
        {
            if(Q[num].size()==0)//没有东西
                 continue;
            if(sk.size()>=S)//满了拿掉一个
            {
                int wp= sk.top();
                sk.pop();
                ans.push_back(wp);               
            }
           int wpp=Q[num].front();
            Q[num].pop();
            sk.push(wpp);          
        }
    }
    int n=ans.size();
    

    for(int i=0;i<n;i++)
    {
        cout<<(char)ans[i];
    }
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

L2-038 病毒溯源

#include<bits/stdc++.h>
using namespace std;
vector<int>G[10001];
vector<int>ans;
vector<int>temp;
int Maxd=0;
void dfs(int u,int k)
{
    if(G[u].size()==0)
    {
        if(k>Maxd)
        {
            ans=temp;
            ans.push_back(u);
            Maxd=k;
        }
        return ;
    }
   
    for(int i=0;i<G[u].size();i++)
    {
        temp.push_back(u);
         dfs(G[u][i],k+1);
        temp.pop_back();
    }    
}
int vis[100000]={0};
int main()
{
    int N;
    cin>>N;
    for(int i=0;i<N;i++)
    {
        int K;
        int x;
        cin>>K;
      
            
        while(K--)
        {
            cin>>x;
            G[i].push_back(x);
            vis[x]=1;
        }
    }
    int k;
     for(int i=0;i<N;i++)
    {
         if(vis[i]==0) k=i;
        sort(G[i].begin(),G[i].end());
    }
      dfs(k,1);
    cout<<Maxd<<endl;
    
    if(ans.size()!=0)
        cout<<ans[0];
    for(int i=1;i<ans.size();i++)
        cout<<" "<<ans[i];
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

L2-039 清点代码库

#include<bits/stdc++.h>
using namespace std;  
struct Node
{
    int cnt;
    vector<int>ans;
}node[10005];
map<vector<int>,int>vis;
int main()
{
    int N,M;
    cin>>N>>M;
    getchar();
    for(int i=0;i<N;i++)//10000
    {
        string s;
        vector<int>t;
        for(int j=0;j<M;j++)
        {
            int x;
            cin>>x;
            t.push_back(x);
        }
        vis[t]++;
    }
    int cnt=0;
    stringstream ss;
    for(auto it : vis)
    {
        node[cnt].ans=it.first; 
        node[cnt++].cnt=it.second;
    }
    sort(node,node+cnt,[](const Node &n1,const Node &n2){
        if(n1.cnt!=n2.cnt)
            return n1.cnt>n2.cnt;
        else
        {
          for(int i=0;i<n1.ans.size();i++)
          {
              if(n1.ans[i]!=n2.ans[i])
                  return n1.ans[i]<n2.ans[i];
          }
        }
    });
    cout<<cnt<<endl;
    for(int k=0;k<cnt;k++)
    {
        cout<<node[k].cnt;
        for(int i=0;i<node[k].ans.size();i++)
        {
            cout<<" "<<node[k].ans[i];
        }
        cout<<endl;
    }
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

L2-040 哲哲打游戏

//通过游戏里不同的操作或选择可以从某个剧情点去往另外一个剧情点
#include<bits/stdc++.h>
using namespace std;
vector<int>G[100002];
int main()
{
		
    int N,M;
    cin>>N>>M;
    for(int i=1;i<=N;i++)
    {
        int k;
        cin>>k;
        while(k--)
        {
            int x;
            cin>>x;
            G[i].push_back(x);
        }
    }   
    unordered_map<int,int>vis;
    int u=1;
    while(M--)
    {
        int judge,xz;
        cin>>judge>>xz;
        if(judge==0)
        {
            u=G[u][xz-1];
        }
        else if(judge==1)
        {
            vis[xz]=u;
            cout<<u<<endl;
        }
        else
        {
            u=vis[xz];
        }
       
    }
    cout<<u;
    return 0;
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

L2-041 插松枝

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+5;
vector<int>ans[N];
int cnt=0;
 bool ok(int num)
 {
 	
   int ss = ans[cnt].size();
   if(ss==0)
   		return true;
   if(ans[cnt][ss-1]>=num)
          return true;
    return false;
 }
int main(){
    
    int n,m,k;
    // n:松针片的数量
    // m:小盒子能存放的松针片的最大数量
    // k：一根松枝干上能插的松针片的最大数量
    cin>>n>>m>>k;
    //推送器
    queue<int>q;
    int t;
   for(int i=0;i<n;i++)
   {
       cin>>t;
       q.push(t);
   }
    //盒子
   stack<int>s;
 
   while(!s.empty()||!q.empty())
   {
       int num;
       //从盒子拿且可以插
       if(!s.empty()&&ok(s.top()))
       {
           num = s.top();
           s.pop();
           //插
           ans[cnt].push_back(num);
           
       }else //小盒子上面没有，或者盒子上面松针不满足要求
       {
           while(1)
		   {
		   	   if(!q.empty())  //传送带有
	           {
	               num = q.front();
	               
	               //可以插
	               if(ok(num)) 
	               {
	                   ans[cnt].push_back(num);
	                   q.pop();
	                   break;
	               }
	               else //不可以插,放盒子上，
	               {
	                   if(s.size()==m) //(1)盒子满了,推送器上取到的松针压回推送器,开始下一根松枝的制作。
	                   {
	                       cnt++;
	                       break;
	                      
	                   }
	                   else //盒子没满放盒子上 然后继续去推送器上取下一片 
	                   {
	                       s.push(num);
	                    	q.pop();
	                       
	                   }
	               }
	           }
	           else //传送带没有，盒子上面松针又不满足要求
	           {
	               //(2)  
	               cnt++;
	               break;
	           }
		   } 
         
       }
       
       //(3)插满了
       if(ans[cnt].size()==k)
       {
           cnt++;
       }     
   }
    
    
    for(int i=0;i<=cnt;i++)
    {
    	if(ans[i].size()==0)
    		break;
        for(int j=0;j<ans[i].size();j++)
        {
            if(j==0)
                cout<<ans[i][j];
            else
                cout<<" "<<ans[i][j];
        }
        cout<<endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/399410