久久综合久久自在自线精品自,久久精品二区,狠狠色婷婷久久一区二区

差分�U�束

�W�蛋侦探 — Fri, 31 May 2013 03:25:00 GMT

差分�U�束(difference constraints)�Q�对�Q�两个关键字要理解好�Q?#8220;difference”��单理解就是两个节点的“�?#8221;�Q�对应的��是图中的边权，�?#8220;�U�束”对应的是囄��辏V��这个图的边权不一定都是正敎ͼ�之前我一直很奇怪�ؓ什么做最短�\的时候初始化dis[]��Z��0也可以，那是因�ؓ我没意识到边权可以�ؓ负数�Q�而思维定势地想初始化dis[]�?�Q�那0不就是最��\径了吗，但这里差分约束的最短�\径常常是负数的，所以最短�\径可以不�?�Q�！

看网上讲解的时候要��心�Q�很多�h把最长�\和最短�\是不分的�Q��ؕ��M��?/div>

�q�有很重要的一点很多�h没区分开�Q?/div>

求最��可行解 ==> 把不�{�式划�ؓdv >= dx + Z的�Ş式，卛_��?lt;u,v,Z>�?==> 可行解要最��，其实��是取约束条件中`最大`的约�?==> 求最长�\

解释�Q��ؓ什么求最��可行解要划成dv >= dx + Z形式�Q�因��个�Ş式暗指了“让dv��量��?#8221;�Q�因为此刻dv的取值区间�ؓ[du+Z, ∞]�?/div>

��Z��么可行解最��，��x��味着取最大约束条�Ӟ��q�样惻I��如果有dv >= du + Z1, dv >= du + Z2�Q?Z1

最后一步就好理解了�Q�因为徏囄��Ҏ��是�U�束��|��既然上一步指要取最大约束，那当然是求最长�\啦�?/div>

�|�上很多讲解没有区分开所谓的最�?最��，一会儿指可行解的最�Q�一会儿指约束条件的最�Q�弄得我�׃��好久�?/div>

��Z��贴一下：

求最大可行解 ==> 把不�{�式划�ؓdv <= dx + Z的�Ş式，卛_��?lt;u,v,Z>�?==> 其实��是取约束条件中`最��`�U�束 ==> 求最短�\

关于源点�Q�很多时候额外�h格源点可以帮我们把一个非�q�通图变成�q�通图�Q�而对于源点的不等式，一定要和你之前��时的不等式�Ş式一��P��如果之前是dv >= du + Z�Q�那源点也要dv >= d0 + xxx。这个xxx��是dis[]的初始��|��关于如何选取xxx�Q�下面两句话摘自癑ֺ�癄��Q?/div>

“

1.如果��源点到各点的距��d��始化�?�Q�最�l�求出的最短�\满�� 它们之间�怺�最接近�?/div>

2.如果��源点到各点的距��d��始化为INF(无穷�?�Q�其中之1�?�Q�最�l�求出的最短�\满�� 它们与该点之间相互差值最大�?/div>

”

差分�U�束题目我一般是用SPFA+栈，��Z��么不用dijkstra+heap�Q�因为dijkstra不能处理负环�Q�而我们的题目可能有负环，所以干脆都用SPFA了，多数条�g下，用stack的SPFA比用queue的快�Q�why�Q�因为常常地�Q�用最先更��C��的点��L��新其它点�Q�效果比用以前已�l�更��C��的点(在queue的tail)好�?/div>

差分�U�束专题�Q�http://972169909-qq-com.iteye.com/blog/1185527

poj 1201 差分�U�束

题意�Q�求�W�合题意的最��集合Z的元素个敎ͼ��U�束条�g:i j C�Q�表区间[i,j]臛_��有C个Z集合的元素�?/div>

隐含条�g是，S区间是个�q�箋的数字区��_��0 <= s[i+1] - s[i] <= 1�Q�其中s[i]�?~i中有多少数字是Z集合元素。下面是隐含条�g的徏辏V�?/div>

for(int i = 0; i < 50001; i++) { //@

vert[i].push_back(i+1); edge[i].push_back(0);

vert[i+1].push_back(i); edge[i+1].push_back(-1);

}

poj 1364 差分�U�束

题意�Q�约束条�Ӟ��i, n, op, K --> op分greater和less�Q�需要满��Si + S[i+1] + S[i+2] + ... + S[i+n] > K �Q�或��于�Q?/div>

因�ؓ我是用dis[i]表示S0+S1+...+Si的和�Q�所�?lt;u,v,w>应该表示的意思是sum[v]-sum[u-1] = w�Q�所以这�?也是一个点�Q�所以源点不能取0�Q?/div>

//@ ?? 我在SPFA后面输出了dis[]数组来看�Q�这些值�ƈ不符合题目的要求�Q�那��Z��么整个程序是对的�Q�如果要输出一个解的话怎么写？

�{�：因�ؓ�q�里的dis[i]表示的是s1+s2+...+si的和�Q�用�W�一个样例来��_��

sample input:

4 2

1 2 gt 0

2 2 lt 2

输出的dis[0--n] : -1 0 0 0 0

s1+s2+s3 = sum[3] - sum[1-1] = dis[3] - dis[0] = 1 , 满��gt 0

s2+s3+s4 = sum[4] - sum[2-1] = dis[4] - dis[1] = 0 , 满��lt 2

所以，{si}的一�l�解应该�?,1,0,0,0.

poj 1983 差分�U�束

题意�Q�给��Z��U�约束条�Ӟ��一�U�是P A B X�Q�意为精��地�U�束A比B�q�X个单位；另一�U�V A B�Q�意为模�p�地�U�束A臛_��比B�q?个单位。是否有可行解？

好点�Q�两�U�约束条�Ӟ��其中Precise�U�束可以转换为X <= A-B <= X

有V i i �q�种数据�Q�这�U�数据在SPFA里会WA�Q�在ballman_ford里AC�Q�不�q�预处理一下就可以了，�q�是用SPFA.

hdu 3666 差分�U�束

题意�Q�给出矩阵{Cij}�Q�问是否存在数列{A} �?{B}�Q��得对于矩阵内所有Xij满��: L <= Xij * Ai / Bj <= U

构图。用log把乘除变成加减，��可以差分约束来做了。我用的是SPFA+stack求最短�\�Q�最长�\应该也是可以的。没有徏源点�Q�直接一开>始把所有点push�q�去... 14xx ms �q�挺险的~

�W�蛋侦探 2013-05-31 11:25 发表评论

查分�U�束 poj 3159

�W�蛋侦探 — Tue, 28 May 2013 07:51:00 GMT

做第一道查分约束poj 3159...TLE不断。估计管理员是跟C++的STL�q�不去，��卡用vector的�h了。。而我已经好久好久没�h工写什么邻接表�Q�前向星什么的了，��只能TLE�q�不了了。。换了什么dijkstra+优先队列�Q�SPFA+stack优化�Q�只要用vector来存边，估计都过不了�?br />下面是TLE代码�Q�留�U�念�?br />

#include <string.h>
#include
#include
using namespace std;
int n, m;
int dis[30001];
bool visit[30001];
int S[30001], S_top = 0;
vector<int> vert[30001], edge[30001];
void dijkstra(int s);
int main()
{
    int u,v,w;
    scanf("%d%d", &n, &m);
    for(int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        vert[u].push_back(v);
        edge[u].push_back(w);
    }
    dijkstra(1);    //最长�\-----不是的，是最短�\�Q?/span>
    printf("%d\n", dis[n]);
}
void dijkstra(int s)
{
    memset(dis, 127, sizeof(dis));
    dis[s] = 0;
    visit[s] = true;
    S[++S_top] = s;
    while(S_top > 0) {
        int u = S[S_top--];
        visit[u] = false;
        for(int Size = vert[u].size(), i = 0; i < Size; i++) {
            int v = vert[u][i];
            if(dis[v] > dis[u] + edge[u][i]) {
                dis[v] = dis[u] + edge[u][i];
                if(visit[v] == false) {
                    S[++S_top] = v;
                    visit[v] = true;
                }
            }
       }
   }
}

�W�蛋侦探 2013-05-28 15:51 发表评论

hdu 2433

�W�蛋侦探 — Mon, 27 May 2013 09:56:00 GMT

最短�\ 好题

题意�Q�给��建图�Q�然后分别删除各条边�Q�问每一�ơ删边后的所有端点的两两最短�\之和�Q�若有一对端点不�q�通，则返回INF

思�\�Q�暴力解法是每次删边后都来n�ơ最短�\。这里面的冗余就是删除的边�ƈ不媄响一些点的最短�\树，所以这些点可以不用在删边后都来�ơdijkstra>。标�E�解法就是在暴力解法上加上一些剪枝。先预处理出所有点的最短�\树，记x的最短�\树的和�ؓsum[x]。现在来��L��冗余�Q�在预处理时用used[x][u][v]记录点x的最短�\树是否用��C��边u--v�Q�则删除边u--v的时候，判断点x的最短�\树是否用到边u--v的，若用刎ͼ�则对x做一�ơdijkstra�Q�用新的sum[x]表示>当前最短�\树；否则用预处理的sum[x]��可以，不用再dijkstra.

dijkstra是利用`�Ҏ��?`�q�一�Ҏ��来加快的版本，具体�?http://m.shnenglu.com/keroro/archive/2013/05/27/200621.html

�q�道题有很多重边�Q�这估计也是考点之一�Q�不好好处理重边的话会超时�?/div>

多数题解是错的，因�ؓhdu上的�q�道题的数据比较水才可以�q�，可以试试discuss里给的数据，下面�q�几个题解比较靠谱�?/div>

http://blog.csdn.net/nash142857/article/details/8253913

http://www.cnblogs.com/crisxyj/archive/2013/03/10/2952396.html

http://hi.baidu.com/novosbirsk/item/bfcf0cd201edfc2d39f6f709

两䆾代码的思想是完全一��L��Q�只�?#8220;baidu blog”那䆾用w[i][e]来判断i的最短�\树是否包括边e�Q�而cnblog的那份是用used[x][u][v]来判断边u-->v是否xxx.

#include
#include
#include <string.h>
#include
#include
using namespace std;
#define     MAXN    101
#define     INF     99999999
#define     debug   printf("!\n")
struct Edge { int u,v; } edge[3001];
vector<int> vertex[MAXN];
int visit[MAXN], sum[MAXN], cnt[MAXN][MAXN];        //cnt[u][v]表u--v的边有多��条�Q�用来处理重�?/span>
bool used[MAXN][MAXN][MAXN];                        //used[x][u][v]x的最短�\树是否用��C��边u--v
int n, m;

void init();
void dijkstra(int s, int when, int flag);
int main()
{
    int when = 0;
    int u, v;
    while(scanf("%d%d", &n, &m) != EOF) {
        init();
        for(int i = 0; i < m; i++) {
            scanf("%d%d", &u, &v);
            vertex[u].push_back(v);
            vertex[v].push_back(u);
            edge[i].u = u, edge[i].v = v;
            cnt[u][v]++, cnt[v][u]++;
        }
        int ans = 0;
        for(int i = 1; i <= n; i++) {
            dijkstra(i, ++when, 1);
            ans += sum[i];
        }
        for(int i = 0; i < m; i++) {
            int tmp = ans;
            int u = edge[i].u, v = edge[i].v;
            //forbid_u = edge[i].u, forbid_v = edge[i].v;       因�ؓ有重�Ҏ��以不能用�q�种�Ҏ��
            for(int j = 1; j <= n; j++) if(used[j][u][v] && cnt[u][v] == 1) {       //不加cnt[u][v] == 1会超时。。卡的就是重边，靠！
                int tmp = sum[j];
                sum[j] = 0;
                //vector :: iterator it1 = find(vertex[u].begin(), vertex[u].end(), v);
                //vector :: iterator it2 = find(vertex[v].begin(), vertex[v].end(), u);
                //*it1 = u, *it2 = v;
                cnt[u][v]--, cnt[v][u]--;
                dijkstra(j, ++when, 2);
                cnt[u][v]++, cnt[v][u]++;
                //*it1 = v, *it2 = u;     //本来是用erase的，��时了�?nbsp;现在换这�U�方法也��时了，估计find耗时太久�?/span>
                ans = ans - tmp + sum[j];   //用新的sum[j]来代替旧的tmp
                sum[j] = tmp;
                int k ;
                for(k = 1; k <= n; k++) if(visit[k] != when) break;     //如果删边了以后j不能到达k(即k没有�q�过�?
                if(k <= n) {
                    ans = INF;
                    break;
                }
            }
            ans == INF ? printf("INF\n") : printf("%d\n", ans);
            ans = tmp;  //不要把这个tmp和for_j里的tmp混了..
        }
        for(int i = 0; i < m; i++) cnt[edge[i].u][edge[i].v] = cnt[edge[i].v][edge[i].u] = 0;   //初始�?img src="http://m.shnenglu.com/Images/dot.gif" alt="" />因�ؓ感觉memset(cnt)会不会花更多旉��
    }
    return 0;
}
void dijkstra(int s, int when, int flag)
{
    int floors = 1;
    int cur = 0;
    deque<int> Q[2];
    Q[cur].push_back(s);
    visit[s] = when;
    do {
        while(!Q[cur].empty()) {
            int u = Q[cur].front();
            Q[cur].pop_front();
            for(int Size = vertex[u].size(), i = 0; i < Size; i++) {
                int v = vertex[u][i];
                if(visit[v] != when && cnt[u][v] > 0) {
                    if(flag == 1) used[s][u][v] = used[s][v][u] = true;   //�W�一�ơ最短�\才标记used因�ؓ懒得写两遍，所以要flag来标记是删边前还收删边后做的最短�\�Q?则是预处理时的最短�\�Q�此时要标记used�Q?则是删边后的最短�\�Q�这个时候不能标记used.
                    visit[v] = when;
                    sum[s] += floors;
                    Q[1-cur].push_back(v);
                }
            }
        }
        floors++;
        cur = 1 - cur;
    } while(!Q[cur].empty());
}
void init()
{
    memset(sum, 0, sizeof(sum));
    memset(used, false, sizeof(used));
    for(int i = 1; i <= n; i++) vertex[i].clear();
}

�W�蛋侦探 2013-05-27 17:56 发表评论

hdu 2377

�W�蛋侦探 — Mon, 27 May 2013 09:52:00 GMT

最短�\, �l�点集合到s的最�q�距��L��短，求s. 卛_��知终炚w��rlcxhru求一s使得Min{ max{ dis(s, di) } }

好题

思�\�Q? 多次单源最短�\�Q�选出最大�?/div>

在对每个x�q�行分层搜烦的过�E�中, 用max_d[y]记录每个地区x到达地区y的最短距��M��的最大�? 最后求得的Star Value��是max_d[]中的最��?

�׃��题目的特�D�性`�Ҏ��都�ؓ1`�Q�所以可以借助�q�一性质变换一下SPFA使其更快�?/div>

说个题外话，在��高时看到有个学弟拓扑排序用到“分层思想”�Q�一直觉得很妙。就是拓扑后我们可以得到floor[i]�Q�如果floor[i] > floor[j]�Q�即说明j是i的前��p��点（层数��小��接�q�root�Q? 而floor[i] == floor[j]的话则i�Q�j的相寚w��序无所谓，因�ؓ他们都在“同一�?#8221;�?/div>

�q�里因�ؓ�Ҏ��都�ؓ1�Q�所以SPFA可以用到上述的分层思想�Q�层数越高，��source��远。代码里面floors��p��C�层敎ͼ�Q是滚动队列，��是一层一层地relax后��节点�?/div>

注意�Q�！千万不要以�ؓmax_d[]是最短�\��法里面的dis[]�Q�这里的max_d[i]是到点i到终炚w��合{di}的最大��|��而常规最短�\��法里的dis[]已经被省略�ؓ“层数”了，不需要记录，所以没开数组�?/div>

最重要的是学到一个tip�Q�！以前我做多次最短�\的时候总要每次都初始化visit[] -> false�Q�但其实不用的，我们只要用一个变量when表示“�q�是�W�几�ơ做SPFA(或其�?“�Q�然后每�ơ入队前都看”是否当前visit[v] == when��可以直到改�Ҏ��否已�l�入�q�队......

#include
#include <string.h>
#include
#include
using namespace std;
#define     debug   printf("!\n")
#define     INF     999999999
#define     MAXN    10000
int n;
int max_d[MAXN];
int visit[MAXN];
vector<int> v[MAXN];

void SPFA(int s, int when);
void init();
int main()
{
    int cases, query, id, m, y, x;
    scanf("%d", &cases);
    while(cases--) {
        scanf("%d%d", &n, &query);
        init();
        for(int i = 0; i < n; i++) {
            scanf("%d%d", &id, &m);
            while(m--) {
                scanf("%d", &y);
                v[id].push_back(y);
            }
        }
        int when = 0;
        while(query--) {
            scanf("%d", &m);
            while(m--) {
                scanf("%d", &x);
                SPFA(x, ++when);
            }
        }

        int ans = INF, ans_id = -1;
        for(int i = 1; i < MAXN; i++) if(!v[i].empty() && max_d[i] < ans) ans = max_d[i], ans_id = i;
        printf("%d %d\n", ans, ans_id);
    }
    return 0;
}
void init()
{
    for(int i = 0; i < MAXN; i++) v[i].clear();
    memset(max_d, 0, sizeof(max_d));
    memset(visit, 0, sizeof(visit));
}
void SPFA(int s, int when)
{
    deque<int> Q[2];
    int cur = 0;
    Q[cur].push_back(s);
    max_d[s] = max(max_d[s], 1);
    visit[s] = when;
    int floors = 1;
    do {
        floors++;
        while(!Q[cur].empty()) {
            int at = Q[cur].front();
            Q[cur].pop_front();
            for(int Size = v[at].size(), i = 0; i < Size; i++) {
                int to = v[at][i];
                if(visit[to] != when) {     //是否已入�?br />                    //max_d[to] = max(max_d[to], max_d[at]+1);      �q�句是不对的�Q�因��个分层跟拓扑排序的分层是不一��L��Q�拓扑排序是要在入度�?时才能加�q�队Q�Q�所以可以这样写�Q�但是这里只要第一�ơ遇见点to��必��d��入队�Q�因��的是最短�\�?/span>
                    max_d[to] = max(max_d[to], floors); //不把�q�句攑֜�if外面�Q�因��里的max_d[to]是距��s的最短�\径，最短�\径也��是最��层敎ͼ�最��层数在to�W�一�ơ入队的时候已�l�得��C��
                    visit[to] = when;
                    Q[1-cur].push_back(to);
                }
            }
        }
        cur = 1 - cur;
    } while(!Q[cur].empty());
}

�W�蛋侦探 2013-05-27 17:52 发表评论

hdu 2586

�W�蛋侦探 — Thu, 16 May 2013 18:44:00 GMT

/*
    最��公��q��?br />    题意: �l�出一颗无向有�Ҏ��? 询问若干�?u,v)对的距离.

    所谓LCA 的Tarjan��法, 实际上就是在建树的过�E�中把query中的lca�l�计��出�? 所以称为`��ȝ��法` . 是的, 本质��是�q�么��? 好多解释都搞复杂�?

    步骤�? 自己google.
    理解�q�个��法一定要抓住`递推`的思想(也有递归在里�? 也要抓住).
    Tarjan是利用�ƈ查集实现�? 在递推�q�程�? 一��|��的root节点代表�q�棵�?联系�q�查集来�?, �q�样做的好处�? 如果问点i与j的lca, 我们只要找i,j都属于的最��的哪棵子树��p��? 因�ؓ该子树就是我们的�{�案. 那如何确定是那颗子树�? �q�一点后面再解释一�?
    下面说Tarjan最巧妙的点�? 因�ؓ是在建树的过�E�中计算所有query, 也就表示我们此刻是否能计��某一query�?u,v)的条件是 : u和v是否都已�l�遍历过. 所以我们可以在遍历到点v(假设�l�历v的时间比u�?的时候把query�l�计��出�? 比如lcm(u,v)��是find(u). 那此�ȝ��find(v)和lcm(u,v)�怸�相等�? �{�案是不相等, 臛_��在我的代码实��C��不相�{? 因�ؓfather[x]的更新是在`递归回去`的时候更新的, 而此��d��遍历v�? �q�没递归回去�? father[v]当然也就没更新啦.
    其实上一�D�就已经回答了`如何��定哪棵子树是我们想要的�{�案`�q�一问题�? ��是find(u)所代表的子�? 注意, 是find(u), 不是find(v)! 因�ؓu是在v之前已经被遍历过�? �q�且递归回去�q�sub_root�q�了, 也就是father[u]被更��Cؓsub_root�? 所以find(u)可以代表当前的sub_tree, 即`最��包�?u,v)子树`

下面两个解释, 推荐一�? �|�嗦一�? 看代码更�Ҏ��理解, ��模拟一遍更�Ҏ��理解
    http://www.nocow.cn/index.php/Tarjan%E7%AE%97%E6%B3%95
    http://blog.chinaunix.net/uid-1721137-id-181005.html
*/
#include
#include
using namespace std;
#define     MAXN    40001
#define     debug   printf("!\n")
vector<int> v[MAXN], w[MAXN], query[MAXN], ans_num[MAXN];
int father[MAXN], dis[MAXN], ans[201];
bool visit[MAXN];
int n;

void init()
{
    for(int i = 1; i <= n; i++) {
        v[i].clear();
        w[i].clear();
        ans_num[i].clear();
        query[i].clear();
        father[i] = i;
        dis[i] = 0;
        visit[i] = false;
    }
}

int find(int x)
{
    return x == father[x] ? x : father[x] = find(father[x]);
}
void Union(int x, int y) { father[find(y)] = find(x); }
void Tarjan(int now, int value)
{
    visit[now] = true;
    dis[now] = value;
    for(int Size = v[now].size(), i = 0; i < Size; i++) {
        int tmp = v[now][i];
        if(visit[tmp] != 0) continue;
        Tarjan(tmp, value + w[now][i]);
        Union(now, tmp);            //注意��序, 先Tarjan子节点tmp, 再更新其father[tmp], 因�ؓ要保证在递推tmp所代表的子树时, father[tmp] = tmp, 而与当前子树无关. 递归回来的时候再把tmp代表的子树`�q�入`到当前树�?/span>
    }

    for(int Size = query[now].size(), i = 0; i < Size; i++) {
        int tmp = query[now][i];
        if(!visit[tmp]) continue;       //若visit[tmp] == true, 卌��C�tmp节点已经遍历�q? 此时可计��相应的query
        ans[ans_num[now][i]] = dis[now] + dis[tmp] - 2 * dis[find(tmp)];
    }
}

int main()
{
    int cases, Query, x, y, z;
    scanf("%d", &cases);
    while(cases--) {
        scanf("%d%d", &n, &Query);
        init();
        for(int i = 1; i < n; i++) {
            scanf("%d%d%d", &x, &y, &z);
            v[x].push_back(y);
            w[x].push_back(z);
            v[y].push_back(x);
            w[y].push_back(z);
        }

        for(int i = 0; i < Query; i++) {
            scanf("%d%d", &x, &y);
            query[x].push_back(y);
            query[y].push_back(x);
            ans_num[x].push_back(i);
            ans_num[y].push_back(i);
        }
        Tarjan(1, 0);
        for(int i = 0; i < Query; i++) printf("%d\n", ans[i]);
    }
    return 0;
}

�W�蛋侦探 2013-05-17 02:44 发表评论