2016.10.11 队内胡策模拟

T1 高精+-* 数据有误 期望100 实际80
T2是二分答案 一直在推怎样二分 没做出来 浪费太多时间 导致T3 T4没有码完
T3最短路+最小生成树+图内加边 注意在两个数组里分别存图和树的值
T4线段树区间修改 区间查询 正解并查集 代码很短而且跑的飞起

T1：
输入数据
只有一行，第一个参数是一个字符， 加号代表要做加法运算， 减号代表要做减法运算，
星号代表乘法运算， 后面有两个大正数， 三个参数间用空格隔开。减法保证前一个大于后一个。
输出数据
只有一行，为运算的结果。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
const int maxn = 5000;
char fh,a1[maxn],b1[maxn];
int a[maxn],b[maxn],c[maxn],lena,lenb;
int main()
{
    freopen("iphone.in","r",stdin);
    freopen("iphone.txt","w",stdout);
    int lenc = 0;
    scanf("%c",&fh);
    if(fh == '+')
    {
        int i;
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        memset(c,0,sizeof(c));
        scanf("%s%s",&a1,&b1);
        lena = strlen(a1);
        lenb = strlen(b1);
        for(int i = 0;i < lena;i ++)
        {
            a[lena-i] = a1[i] - '0';
        }
        for(int i = 0;i < lenb;i ++)
        {
            b[lenb-i] = b1[i] - '0';
        }
        lenc = 1;
        int x = 0;
        while(lenc <= lena||lenc <= lenb)
        {
            c[lenc] = a[lenc] + b[lenc] + x;
            x = c[lenc] / 10;
            c[lenc] %= 10;
            lenc ++;  
        }  
        c[lenc] = x;
        if(c[lenc] == 0 && i != 0) lenc -- ;
        for(int i = lenc;i >= 1;i --)
            cout<<c[i];
            cout<<endl;
    }
    else if(fh == '-')
    {
        string a2,b2;  
        cin>>a2>>b2;  
        if (a2.size()<b2.size()||(a2.size()==b2.size()&&a2<b2)) 
        {  
            swap(a2,b2);  
            cout<<"-";  
        }  
        for (int i=1;i<=b2.size();i++)  
        {  
            a2[a2.size()-i]=a2[a2.size()-i]-b2[b2.size()-i]+'0';   
        }  
        for (int i=1;i<=a2.size();i++)  
        {  
            if (a2[a2.size()-i]<'0')             
            {  
                a2[a2.size()-i-1]-=1;  
                a2[a2.size()-i]+=10;  
            }  
        }  
        int k;  
        for (k=0;k<a2.size();k++)        
        {  
            if(a2[k]!='0')  break;  
        }   
        for (int i=k;i<a2.size();i++)  
        {  
            if (a2[i]>='0'&&a2[i]<='9')    
                cout<<a2[i];  
        } 
    }
    else if(fh == '*')
    {
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        memset(c,0,sizeof(c));
        scanf("%s",&a1);        lena = strlen(a1);
        scanf("%s",&b1);        lenb = strlen(b1);
        int i,j;
        for(i = 0; i < lena; i ++)  a[lena - i - 1] = a1[i] - '0';
        for(i = 0; i < lenb; i ++)  b[lenb - i - 1] = b1[i] - '0';
        for(i = 0; i < lenb; i ++)
        for(j = 0; j < lena; j ++)
        {
            c[j + i] += b[i] * a[j];
        }
        for(i = 0; i < lena + lenb; i ++)
        {
            if(c[i] >= 10) 
            {
                c[i + 1] += c[i] / 10;
                c[i] = c[i] % 10;
            }
        }
        i = lena + lenb - 1;
        while(c[i] == 0 && i != 0)
            i --;
        for(; i >= 0; i --)
            printf("%d",c[i]);
    }
    fclose(stdin);
    fclose(stdout);
    return 0;
}

T2：改编自codevs2744 养鱼喂妹纸 刚刚有写过
链接：题解

T3：
输入格式
输入文件的第一行为两个正数 n, m 代表原图内的点总数和边总数。
以下 m 行， 每行三个正数 u, v, l. 代表每条边连接的两个点以及其长度。
再一行只有一个正数 q， 代表操作数。
接下来每行先是一个正数 p, 若 p 为 1 则后面跟着两个正数 s, t。 请输出从 s 点到 t点屿的最短路径长度；
若 p 为 2， 则输出连接图内各个点使得各个点都互相联通的最短路径长度；
若 p 为 3， 则后跟三个正数 a, b, d, 代表在 a, b 之间添加一条长度为 d 边。
输出格式
与输入文件操作中 1, 2 操作数对应。

注意图和树分别存一下
代码：

#include<iostream>
#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
int n,m;
struct edge{
    int to,nxt,d;
}b[230005];
int fst[10005],tot;
void build(int f,int t,int d)
{
    b[++tot].to=t;
    b[tot].d=d;
    b[tot].nxt=fst[f];
    fst[f]=tot;
}

int dis[10005];
int inf=1e9;
deque<int> q;
bool use[10005];
void spfa(int s)
{
    for(int i=1;i<=n;i++)
        dis[i]=inf;
    dis[s]=0;
    q.push_back(s);
    while(!q.empty())
    {
        int u=q.front();
        use[u]=0;q.pop_front();
        for(int i=fst[u];i;i=b[i].nxt)
        {
            int v=b[i].to;
            if(dis[v]>dis[u]+b[i].d)
            {
                dis[v]=dis[u]+b[i].d;
                if(!use[v])
                {
                    if(!q.empty()&&dis[q.front()]>dis[v])
                        q.push_front(v);
                    else
                        q.push_back(v);
                    use[v]=1;
                }
            }
        }
    }
}

int cnt;
struct tree{
    int f,t,dd;
}c[150005];
bool cmp(tree a,tree b)
{return a.dd<b.dd;}
int fa[10005];
int find(int x)
{return fa[x]==x?x:fa[x]=find(fa[x]);}
int kur()
{
    for(int i=1;i<=n;i++)
        fa[i]=i;
    sort(c+1,c+cnt+1,cmp);
    int u,v,ans=0;
    for(int i=1;i<=cnt;i++)
    {
        u=c[i].f;v=c[i].t;
        if(find(u)!=find(v))
        {
            fa[find(u)]=find(v);
            ans+=c[i].dd;
        }
    }
    return ans;
}

int main()
{
    freopen("forbidden.in","r",stdin);
    freopen("forbidden.out","w",stdout);
    scanf("%d%d",&n,&m);
    int u,v,l;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&l); 
        build(u,v,l);build(v,u,l);
        c[++cnt].f=u;
        c[cnt].t=v;
        c[cnt].dd=l;
    }
    int Q,p;
    scanf("%d",&Q);
    for(int i=1;i<=Q;i++)
    {
        scanf("%d",&p);
        if(p==1)
        {
            scanf("%d%d",&u,&v);
            spfa(u);
            printf("%d\n",dis[v]);
        }
        if(p==2)
        {
            int ans=kur();
            printf("%d\n",ans);
        }
        if(p==3)
        {
            scanf("%d%d%d",&u,&v,&l);
            build(u,v,l);build(v,u,l);
            c[++cnt].f=u;
            c[cnt].t=v;
            c[cnt].dd=l;
        }
    }
    fclose(stdin);
    fclose(stdout);
    return 0;
}

T4 改编自 codevs1191 数轴染色
我们考虑以下 一开始所有的点都为白点 没进行一次操作之后 整个区间就会变成黑点
把这些点的值改为0 最后求一下整棵树的值（tree[1].sum）就可以了

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 200000 +10;
int n,m,l,r;
struct doc{
    int l,r,sum,add;
}tree[maxn<<2];
void up(int p)
{
    tree[p].sum = tree[p*2].sum + tree[p*2+1].sum;
}
void push(int p)
{
    tree[p*2].sum += (tree[p*2].r - tree[p*2].l + 1)*tree[p].add;
    tree[p*2+1].sum += (tree[p*2+1].r - tree[p*2+1].l + 1)*tree[p].add;
    tree[p*2].add += tree[p].add;
    tree[p*2+1].add += tree[p].add;
    tree[p].add = 0;
}
void build(int p,int l,int r)
{
    tree[p].l = l;
    tree[p].r = r;
    if(l == r)
    {
        tree[p].sum = 1;
        return ;
    }
    int mid = (l + r) / 2;
    build(p*2,l,mid);
    build(p*2+1,mid+1,r);
    up(p);
}
void change(int p,int l,int r,int v)
{
    if(l <= tree[p].l && tree[p].r <= r)
    {
        tree[p].sum = v * (tree[p].r - tree[p].l + 1);
        if(tree[p].sum <= 0) tree[p].sum = 0;
        tree[p].add += v;
        return ;
    }
    push(p);
    int mid = (tree[p].l + tree[p].r) / 2;
    if(l <= mid) change(p*2,l,r,v);
    if(mid < r) change(p*2+1,l,r,v);
    up(p);
    if(tree[p].sum < 0) tree[p].sum = 0;
}

int main()
{
    scanf("%d%d",&n,&m);
    build(1,1,n);
    for(int i = 1;i <= m; i ++)
    {
        scanf("%d%d",&l,&r);
        change(1,l,r,-1);
        printf("%d\n",tree[1].sum);
    }
    return 0;
}

并查集的方法更为简洁
我们考虑一下 染色保证所有的点最多被染色一次 每次进行染色的过程其实可以看做把这一整个区间看做一个点 即以后再染的时候就直接作为一个点集合去处理
这不就是合并的过程吗？ 这样就可以利用并查集去解了
首先我们初始化每个白色点都是自己的父节点 从左向右开始染色 用并查集维护一下 每染一次色就让连续的黑色点合并找下一个白色点 作为自己的父节点 这样我们每次处理之后记录一下还有多少个根节点 就是答案

#include<cstdio>
#include<cstring> 
#include<iostream>
#include<algorithm>
using namespace std;
int fa[200010];
int find(int x)
{
    return fa[x]==x?x:fa[x]=find(fa[x]);
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=0;i<=n;i++) fa[i]=i;
    while(m--)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        while(find(y)!=find(x-1)) fa[find(y)]=fa[find(y)-1],n--;
        printf("%d\n",n); 
    } 
    return 0;