CodeForces 605B Lazy Student

构造。对边的权值排序,权值一样的话,在MST中的边排到前面,否则权值小的排在前面。

然后边一条一条扫过去,如果是1 ,那么连一个点到集合中,如果是0,集合内的边相连。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;

const int maxn=100000+10;
struct Edge
{
    int u,v;
    int w;
    int info;
    int id;
} e[maxn];
int n,m;
int flag;
int last[maxn];
int K;
int now;

bool cmp(const Edge&a,const Edge&b)
{
    if(a.w==b.w) return a.info>b.info;
    return a.w<b.w;
}

bool cmp2(const Edge&a,const Edge&b)
{
    return a.id<b.id;
}

void init()
{
    now=1;
    flag=0;
    K=2;
    for(int i=1; i<=n; i++) last[i]=i;
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(int i=1; i<=m; i++)
        {
            scanf("%d%d",&e[i].w,&e[i].info);
            e[i].id=i;
        }
        sort(e+1,e+m+1,cmp);

        for(int i=1; i<=m; i++)
        {
            if(e[i].info==1)
            {
                e[i].u=1;
                now++;
                e[i].v=now;

                K=2;
            }
            else if(e[i].info==0)
            {
                while(1)
                {
                    if(K>=now+1)
                    {
                        printf("-1\n");
                        flag=1;
                        break;
                    }
                    if(last[K]+1<=now)
                    {
                        e[i].u=K;
                        e[i].v=last[K]+1;
                        last[K]++;
                        break;
                    }
                    else K++;
                }
            }
            if(flag) break;
        }

        sort(e+1,e+m+1,cmp2);

        if(flag==0)
        {
            for(int i=1; i<=m; i++)
                printf("%d %d\n",e[i].u,e[i].v);
        }
    }
    return 0;
}
时间: 2024-10-03 14:56:15

CodeForces 605B Lazy Student的相关文章

codeforce 605B. Lazy Student

题意:n点,m条边.m条边里面标记为1的最小生成树的边,0为非最小生成树的边.给了每条边的权,如果能构成一个最小生成树则输出图,否则-1. 思路:先按权值小,为生成数边的顺序排序.(根据kruskal)再添加每条0边.这里假定(1,3),(2,4)构成环. 1 #include<iostream> 2 #include<string> 3 #include<algorithm> 4 #include<cstdlib> 5 #include<cstdio

Codeforces Round #335 (Div. 2) D. Lazy Student 贪心

D. Lazy Student Student Vladislav came to his programming exam completely unprepared as usual. He got a question about some strange algorithm on a graph — something that will definitely never be useful in real life. He asked a girl sitting next to hi

codeforces #335div2 D. Lazy Student 构造

#include<bits/stdc++.h> #define REP(i,a,b) for(int i=a;i<=b;i++) #define MS0(a) memset(a,0,sizeof(a)) using namespace std; typedef long long ll; const int maxn=1000100; const int INF=1<<29; int n,m; struct Edge { int w,is; int id; friend bo

寒假集训第二天---最小生成树题解

CodeForces - 606D Lazy Student 传送门 题目大意:m条边,每条边给权值和是否在最小生成树里,问能否构造出一个图满足边 思路:排序,对可行的边与1相连,对于不可行的边其它已连结点相连,直到连完或者不满足条件 卡点:对于权值相同的边,在最小生成树里的边的优先级较高 代?? #include <iostream> #include <cstdio> #include <algorithm> #include <vector> usin

codeforces A. Valera and Plates 题解

Valera is a lazy student. He has m clean bowls and k clean plates. Valera has made an eating plan for the next n days. As Valera is lazy, he will eat exactly one dish per day. At that, in order to eat a dish, he needs exactly one clean plate or bowl.

.NET中的按需加载/延迟加载 Lazy&lt;T&gt;

业务场景: 在项目开发中,经常会遇到特定的对象使用的加载问题,有的实例对象我们创建之后并非需要使用,只是根据业务场景来调用,所以可能会导致很多无效的实例加载 延迟初始化出现于.NET 4.0,主要用于提高性能,避免浪费计算,并减少程序内存要求.也可以称为,按需加载 代码事例: 1.未进行延迟加载的情况 a.创建学生类: b.程序入口: c.运行结果: d.结果说明: 程序运行直接调用了构造函数,在使用Student对象之前 2.使用延迟加载 a.创建学生类:(代码如上1) b.程序入口: usi

C#性能优化之Lazy&lt;T&gt; 实现延迟初始化

在.NET4.0中,可以使用Lazy<T> 来实现对象的延迟初始化,从而优化系统的性能.延迟初始化就是将对象的初始化延迟到第一次使用该对象时.延迟初始化是我们在写程序时经常会遇到的情形,例如创建某一对象时需要花费很大的开销,而这一对象在系统的运行过程中不一定会用到,这时就可以使用延迟初始化,在第一次使用该对象时再对其进行初始化,如果没有用到则不需要进行初始化,这样的话,使用延迟初始化就提高程序的效率,从而使程序占用更少的内存. 下面我们来看代码,新建一个控制台程序,首先创建一个Student类

NIT ACM 2014 寒假集训#1 初阶组

一共五题,五题全是CF的.真正会做的就三题,还有两题题目看不懂.其实都是水题.后面我懂了题意之后一下子就补掉了. A题: Vasily the Programmer loves romance, so this year he decided to illuminate his room with candles. Vasily has a candles.When Vasily lights up a new candle, it first burns for an hour and the

Android Dagger依赖注入框架浅析

今天接触了Dagger这套android的依赖注入框架(DI框架),感觉跟Spring 的IOC差不多吧.这个框架它的好处是它没有采用反射技术(Spring是用反射的),而是用预编译技术,因为基于反射的DI非常地耗用资源(空间,时间) 由于现在开发都是用Android Studio了,所以我这里大概讲下配置Dagger框架的开发环境,需要怎么做. (由于Android Studio中用Gradle,所以跟传统我们用Eclipse配置的话,直接导入jar包,有点不一样.) 在开始看我的博文前,希望