NOIP 模拟八

T1：星际旅行：

　　显然根据题目要求，我们能想到该问题可以转化为存在多少种情况，使得删去两条边后存在一条路径可以经过每条边两次

显然有等价于存在一条路径可以经过每条边一次，那么问题显然就是判断是否存在（无向图）欧拉路

然而考场上考虑的却是用Tarjan判断上述条件，显然错误，原因在于基础不牢固并且对于算法本质认识不清

不能在任一情况下应用合适的算法解决问题。

　　返回正题：欧拉路判断方法：

　　欧拉路径：
        无向图：连通，点的度数全为偶数(此时所有点均可以为起点,因为相当于欧拉回路)，或者只有两个点度数为奇数（只有度数为奇数的点才可以为起点)
        有向图：出度和入度相等(所有点可以为起点)，或者只有两个点：其中一个入度+1=出度(起点)，另一个出度+1=入度(终点)
    　欧拉回路
        无向图：连通，点的度数全为偶数(所有点可以为起点)。
        有向图：出度和入度相等(所有点可以为起点)。
    　图论问题中首先要注意重边与自环：重边可利用成对变换判断解决，而自环根据情况可以在输入时continue，而本题显然不能如此
也就是要考虑重边影响，在明确欧拉路判断方法后，此问题显然转化成了一个计数问题，也就是删掉两条边后使得无向图存在0个或2个节点度数为奇数

分别考虑删去两自环，一自环一边，和两边，判断存在多少种删法满足要求（注意首先要判断图的连通性，因为欧拉路的判断是基于图的连通性进行的）。

代码如下：

#include<bits/stdc++.h>
using namespace std;
#define I long long
#define B bool
#define C char
#define RE register
#define V void
#define L inline
const I MAXN = 1e5 + 10;
I n,m,x,y,pd,res,num[MAXN],outit[MAXN];
B jud[MAXN];
struct Disjoint_set{
    I father[MAXN],self[MAXN],tot[MAXN];
    V initial() {   for(RE I i(1);i <= n; ++ i) father[i] = i;  }
    I find(I x) {   return x == father[x] ? x : father[x] = find(father[x]);    }
    V merge(I x,I y){   
        I fx = find(x); I fy = find(y);
        if(fx != fy)    father[fy] = fx,self[fx] += self[fy];
    }
}Disjoint_set;
L I read(); L I fir(I); L I ope(I); 
signed main(){
    n = read(); m = read();
    Disjoint_set.initial();   
    for(RE I i(1);i <= m; ++ i){
        x = read(); y = read();
        if(x == y)  {   Disjoint_set.self[Disjoint_set.find(x)]++;  continue;   }
        Disjoint_set.merge(x,y);  
        outit[x]++; outit[y]++;    
    }
    for(RE I i(1);i <= n; ++ i) {
        I anc = Disjoint_set.find(i);
        num[anc] += outit[i];   Disjoint_set.tot[anc] += fir(outit[i]);
    }
    for(RE I i(1);i <= n; ++ i) {
        if(num[i])  pd++;
        if(pd > 1)  {   printf("0");    return 0;   }
        num[i] >>= 1;
    }
    for(RE I i(1);i <= n; ++ i) {
        I anc = Disjoint_set.find(i);
        if(!jud[anc])   jud[anc] = 1,res += ope(anc);
    }
    printf("%lld",res);
}
L I read(){RE I x(0);RE C z(getchar());while(!isdigit(z))z=getchar();while(isdigit(z))x=(x<<3)+(x<<1)+(z^48),z=getchar();return x;}
L I fir(I x)    {   return x * (x - 1) / 2 ;    }
L I ope(I x){  
    Disjoint_set.tot[x] += fir(Disjoint_set.self[x]);
    Disjoint_set.tot[x] += Disjoint_set.self[x] * num[x];
    return Disjoint_set.tot[x];
}

 

T2：砍树：

　　首先反思做题思路：拿到一道题首先要观察数据范围，根据数据范围判断时空复杂度范围进而确定大致的算法类型，其次应该先判断题目类型是否为数学题，

如若通过推导难以解决那么尝试用数据结构解决问题

　　进入正题：根据数据范围我们可以考虑log类型复杂度，然而考虑数据做法的话无从下手

此时考虑数学解法，对于信息类问题的数学解法首先要对问题进行数学抽象，该问题可以转化为：

　　求一个最大的d，满足：sigma(ceil(ai/d)*d-ai)<=k，令C=k+sigma(ai)，移项得sigma(ceil(ai/d))*d<=C;

显然右侧是一个定值（分离包含多个变量的项，使公式中不同变量之间相互独立的思想），再移项得sigma(ceil(ai/d))<=C/d;

分析发现右侧是一个分段函数，回归问题我们要求满足该不等式最大的d，我们发现对于分段函数上的每一段，右端点显然是最优解，

这理解涉及如何去枚举，如果枚举分段函数纵坐标来计算每一段的右端点，那么时间复杂度为O(sigma),显然会超时，分析发现如果我们直接枚举

右端点进行转移会省去很多不必要的枚举降低复杂度（O(sqrt(k+max(ai)))）,也就是说在枚举过程中，我们要尽量类似此题跳跃性枚举来减少不必要的操作，

当然这需要枚举变量间存在一定的递推关系。

代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
#define I unsigned long long
#define B bool
#define C char
#define RE register
#define V void
#define L inline
I n,k,maxn,sigma,tall[105];
L I read(); L I up(I,I); L I fir(I); 
signed main(){
    n = read(); k = read(); sigma += k; maxn += k; 
    for(RE I i(1);i <= n; ++ i) tall[i] = read(),sigma += tall[i];
    maxn += *max_element(tall + 1,tall + n + 1); 
    for(RE I i(sigma / (sigma / maxn)); i ;i = sigma / (sigma / i + 1))
        if(fir(i) <= sigma / i) {   printf("%lld",i);break;  }
}
L I read(){RE I x(0);RE C z=getchar();while(!isdigit(z))z=getchar();while(isdigit(z))x=(x<<3)+(x<<1)+(z^48),z=getchar();return x;}
L I up(I x,I y) {   return x % y ? x / y + 1 : x / y ;  }
L I fir(I x){   I res(0);
    for(RE I j(1);j <= n; ++ j)
        res += up(tall[j],x);
    return res;
}