2018年1月24日训练日记

发现一个函数：memcpy(b,a,sizeof(a));//把a的内容复制到b里  

发现一个函数：fill(d+2, d+1+n, INF);  //把数组d从d[2]到d[n]初始化为inf

发现一个输入：

template<class T>
inline void read(T &res) {
    char c;res=0;
    while (!(isdigit(c=getchar())));
    while (isdigit(c)) res=res*10+c-'0',c=getchar();
}

然后对于int a;read(a);即为输入a。

优先队列小的优先（不用重载）：priority_queue<int,vector<int>,greater<int> >Q;

2-SAT问题定义：现有一个由N个布尔值组成的序列A，给出一些限制关系，比如A[x]AND A[y]=0、A[x] OR A[y] OR A[z]=1等，要确定A[0..N-1]的值，使得其满足所有限制关系。这个称为SAT问题，特别的，若每种限制关系中最多只对两个元素进行限制，则称为2-SAT问题。可能的限制关系有9种。

问题特点：有N对物品，每对物品中必须选取一个，也只能选取一个，并且它们之间存在某些限制关系（如某两个物品不能都选，某两个物品不能都不选，某两个物品必须且只能选一个，某个物品必选）等，这时，可以将每对物品当成一个布尔值（选取第一个物品相当于0，选取第二个相当于1），通常2*i表示不选，2*i+1表示选。经常结合二分解决最优值问题（如HDU 3715 Go Deeper）

2-SAT模板：

struct twosat{
    int n;
    vector<int> vc[mx<<1];
    int s[mx<<1],c;
    bool mk[mx<<1];
    bool dfs(int x)
    {
        if(mk[x^1]) return 0;
        if(mk[x])return 1;
        mk[x]=1;
        s[c++]=x;
        for(int i=0;i<vc[x].size();i++)
        if(!dfs(vc[x][i])) return 0;
        return 1;
    }
    void init(int m)
    {
        this->n=m;
        for(int i=0;i<(n<<1);i++) vc[i].clear();
        memset(mk,0,sizeof(mk));
    }
    void add(int x,int x1,int y,int y1)//有时候这里会做修改
    {
     x=(x<<1)+x1;
     y=(y<<1)+y1;
     vc[x^1].push_back(y);//vc[x].push_back(y);
     vc[y^1].push_back(x);//无
    }
    bool solve()
    {
        for(int i=0;i<(n<<1);i+=2)
        {
            if(!mk[i]&&!mk[i+1])
            {
                c=0;
                if(!dfs(i))
                {
                 while(c>0) mk[s[--c]]=0;
                 if(!dfs(i+1)) return 0;
                }
            }
        }
        return 1;
    }
}ts;

加二分（例：HDU3715）：

bool ok(int mid)  
{  
    TS.init(n);  
    for(int i=0;i<mid;i++)  
    {  
        if(c[i]==0)//讨论多种情况
        {  
            TS.add_clause(a[i],0,b[i],1);  
            TS.add_clause(b[i],0,a[i],1);  
        }  
        else if(c[i]==1)  
        {  
            TS.add_clause(a[i],0,b[i],0);  
            TS.add_clause(a[i],1,b[i],1);  
            TS.add_clause(b[i],0,a[i],0);  
            TS.add_clause(b[i],1,a[i],1);  
        }  
        else if(c[i]==2)  
        {  
            TS.add_clause(a[i],1,b[i],0);  
            TS.add_clause(b[i],1,a[i],0);  
        }  
    }  
    return TS.solve();  
}  

int L=0,R=m;  
        while(R>L)//二分
        {  
            int mid = L+(R-L+1)/2;  
            if(ok(mid)) L=mid;  
            else R=mid-1;  
        }  
        printf("%d\n",L);

差分约束系统：

定义：差分约束系统（system of difference constraints），是求解关于一组变数的特殊不等式组之方法。如果一个系统由n个变量和m个约束条件组成，其中每个约束条件形如xj-xi<=bk(i,j∈[1,n],k∈[1,m]),则称其为差分约束系统(system of difference constraints)。亦即，差分约束系统是求解关于一组变量的特殊不等式组的方法。

通俗一点地说，差分约束系统就是一些不等式的组，而我们的目标是通过给定的约束不等式组求出最大值或者最小值或者差分约束系统是否有解。
一般题目会有三种情况：1、求取最短路 2、求取最长路 3、判断差分约束系统的解是否存在（一般判环即可）

最重要的还是正确的写出不等式，注意隐含的不等式。经常需要添加0号源点或者把i向右移动一个单位。如果是求最值而且结果具有单调性，需要用二分。建图初始化一定要注意。。。

一篇比较好的资料：

首先根据题目的要求进行不等式组的标准化。                                                                                                                          1、如果要求取最小值，那么求出最长路，那么将不等式全部化成xi – xj >= k的形式，这样建立j->i的边，权值为k的边，如果不等式组中有xi – xj > k，因为一般题目都是对整形变量的约束，化为xi – xj >= k+1即可，如果xi – xj = k呢，那么可以变为如下两个：xi – xj >= k, xi – xj <= k,进一步变为xj – xi >= -k，建立两条边即可。                                                                       2、如果求取的是最大值，那么求取最短路，将不等式全部化成xi – xj <= k的形式, 这样建立j->i的边，权值为k的边，如果像上面的两种情况，那么同样地标准化就行了。                                                                                                                          3、如果要判断差分约束系统是否存在解，一般都是判断环，选择求最短路或者最长路求解都行，只是不等式标准化时候不同，判环地话，用spfa即可，n个点中如果同一个点入队超过n次，那么即存在环。

值得注意的一点是：建立的图可能不联通，我们只需要加入一个超级源点，比如说求取最长路时图不联通的话，我们只需要加入一个点S，对其他的每个点建立一条权值为0的边图就联通了，然后从S点开始进行spfa判环。最短路类似。                              建好图之后直接spfa或bellman-ford求解，不能用dijstra算法，因为一般存在负边，注意初始化的问题。

明天继续加油。