deko2014
deko2014

Tarjan & LCA 套题题目题解

刷题之前来几套LCA的末班

对于题目

HDU 2586 How far away

2份在线模板第一份倍增,倍增还是比较好理解的

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 40040;
const int MAXM = MAXN * 2;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,w;
    int next;
}edge[MAXM];
int head[MAXN],tot;
int N;

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

int dep[MAXN],fa[MAXN],cost[MAXN];
int sumcost[MAXN][20],anc[MAXN][20];
bool vis[MAXN];

void bfs(int root)
{
    memset(vis,false,sizeof(vis));
    queue<int>q;
    q.push(root);
    vis[root] = true;
    fa[root] = -1;
    dep[root] = 0;
    cost[root] = 0;
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        for (int i = head[u] ; i != -1 ; i = edge[i].next)
        {
            int v = edge[i].v;
            if (vis[v]) continue;
            dep[v] = dep[u] + 1;
            cost[v] = edge[i].w;
            fa[v] = u;
            vis[v] = true;
            q.push(v);
        }
    }
}

void preprocess()
{
    memset(sumcost,0,sizeof(sumcost));
    for (int i = 1 ; i <= N ; i++)
    {
        anc[i][0] = fa[i];
        sumcost[i][0] = cost[i];
        for (int j = 1 ; (1 << j) <= N ; j++) anc[i][j] = -1;
    }
    for (int j = 1 ; (1 << j) <= N ; j++)
    {
        for (int i = 1 ; i <= N ; i++)
        {
            if (anc[i][j - 1] != -1)
            {
                int a = anc[i][j - 1];
                anc[i][j] = anc[a][j - 1];
                sumcost[i][j] = sumcost[i][j - 1] + sumcost[a][j - 1];
            }
        }
    }
}


int query(int p,int q)
{
    int tmp,log;
    if (dep[p] < dep[q]) swap(p,q);
    for (log = 1 ; (1 << log) <= dep[p] ; log++); log--;
    int ans = 0;
    for (int i = log ; i >= 0 ; i--)
    {
        if (dep[p] - (1 << i) >= dep[q])
        {
            ans += sumcost[p][i];
            p = anc[p][i];
        }
    }
    if (p == q) return ans;
    for (int i = log ; i >= 0 ; i--)
    {
        if (anc[p][i] != -1 && anc[p][i] != anc[q][i])
        {
            ans += sumcost[p][i]; p = anc[p][i];
            ans += sumcost[q][i]; q = anc[q][i];
        }
    }
    ans += cost[p];
    ans += cost[q];
    return ans;
}

int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        init();
        int Q;
        scanf("%d%d",&N,&Q);
        for (int i = 0 ; i < N - 1 ; i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
        bfs(1);
        //printf("%d %d %d %d\n",fa[2],fa[3],cost[2],cost[3]);
        preprocess();
        //printf("%d %d %d %d\n",anc[2][0],anc[3][0],sumcost[2][0],sumcost[3][0]);
        while(Q--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            printf("%d\n",query(u,v));
        }
    }
    return 0;
}
View Code

第二份DFS+ST+rmq。关于这种算法的解释在代码里有个链接

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626 
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 40010;
const int MAXM = MAXN * 2;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,w;
    int next;
}edge[MAXN * 2];
int head[MAXN],tol;

void init()
{
    memset(head,-1,sizeof(head));
    tol = 0;
}

void add_edge(int u,int v,int w)
{
    edge[tol].u = u;
    edge[tol].v = v;
    edge[tol].w = w;
    edge[tol].next = head[u];
    head[u] = tol++;
}

int ver[MAXN * 2],R[MAXN * 2],first[MAXN],dir[MAXN];
bool vis[MAXN];
int fac[30];
int tot;
int dp[MAXN * 2][30];

void dfs(int u ,int dep)
{
    vis[u] = true; ver[++tot] = u; first[u] = tot; R[tot] = dep;
    for(int i = head[u]; i != -1 ; i=edge[i].next)
        if( !vis[edge[i].v] )
        {
            int v = edge[i].v , w = edge[i].w;
            dir[v] = dir[u] + w;
            dfs(v,dep+1);
            ver[++tot] = u; R[tot] = dep;
        }
}

void ST(int len)
{
    int K = (int)(log((double)len) / log(2.0));
    for(int i = 1 ; i <= len ; i++) dp[i][0] = i;
    for(int j = 1 ; j <= K ; j++)
        for(int i = 1 ; i + fac[j] - 1 <= len ; i++)
        {
            int a = dp[i][j - 1] , b = dp[i + fac[j - 1]][j - 1];
            if(R[a] < R[b]) dp[i][j] = a;
            else            dp[i][j] = b;
        }
}

int RMQ(int x ,int y)
{
    int K = (int)(log((double)(y - x + 1)) / log(2.0));
    int a = dp[x][K] , b = dp[y - fac[K] + 1][K];
    if(R[a] < R[b]) return a;
    else            return b;
}

int LCA(int u ,int v)
{
    int x = first[u] , y = first[v];
    if(x > y) swap(x,y);
    int res = RMQ(x,y);
    return ver[res];
}

int main()
{
    for (int i = 0 ; i < 30 ; i++) fac[i] = (1 << i);
    int T;
    scanf("%d",&T);
    while (T--)
    {
        int N,Q;
        init();
        scanf("%d%d",&N,&Q);
        memset(vis,false,sizeof(vis));
        for (int i = 1 ; i < N ; i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
        tot = 0;
        dir[1] = 0;
        dfs(1,1);
        /*
        printf("节点 "); for(int i=1; i<=2*N-1; i++) printf("%d ",ver[i]); cout << endl;
        printf("深度 "); for(int i=1; i<=2*N-1; i++) printf("%d ",R[i]);   cout << endl;
        printf("首位 "); for(int i=0; i<=N; i++) printf("%d ",first[i]);    cout << endl; 
        printf("距离 "); for(int i=0; i<=N; i++) printf("%d ",dir[i]);      cout << endl;
        */
        //以上四行表示了该模版的全部数组含义详细LCA RMQ在线分析在http://www.cnblogs.com/scau20110726/archive/2013/05/26/3100812.html
        ST(2 * N - 1);
        while (Q--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            int lca  = LCA(u,v);
        //    printf("%d %d %d %d %d %d\n",u,v,dir[u],dir[v],lca,dir[lca]);
            printf("%d\n",dir[u] + dir[v] - 2 * dir[lca]);
        }
    }
    return 0;
}
View Code

 

HDU 1269 迷宫城堡

裸题+中文题！

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
const int MAXN = 10010;
const int MAXM = 300010;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,next;
    int w;
}edge[MAXM];
int N,M;
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int scc;
bool Instack[MAXN];
int degin[MAXN],degout[MAXN];
int num[MAXN];

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (!DFN[v])
        {
            Tarjan(v);
            if (Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if (Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }while (v != u);
    }
}

void deal()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    Index = top = 0;
    scc = 0;
    memset(num,0,sizeof(num));
    for (int i = 1 ; i <= N ; i++)
    {
        if (!DFN[i]) Tarjan(i);
    }
}

int main()
{
    while (scanf("%d%d",&N,&M) != EOF)
    {
        if (N == 0 && M == 0) break;
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797);
        }
        deal();
        printf("%s\n",scc == 1 ? "Yes" : "No");
    }
    return 0;
}
View Code

POJ 2767 Proving Equivalences

强联通推证明题 缩点后统计入度出度为0的点。具体答案是max(cntdegout = 0,cntdegin = 0)。很水直接看代码

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
const int MAXN = 200010;
const int MAXM = 500010;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,next;
    int w;
}edge[MAXM];
int N,M;
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int scc;
bool Instack[MAXN];
int degin[MAXN],degout[MAXN];
int num[MAXN];

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (!DFN[v])
        {
            Tarjan(v);
            if (Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if (Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }while (v != u);
    }
}

void deal()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    top = Index = scc = 0;
    memset(num,0,sizeof(num));
    memset(degin,0,sizeof(degin));
    memset(degout,0,sizeof(degout));
    for (int i = 1 ; i <= N ; i++)
    {
        if (!DFN[i]) Tarjan(i);
    }
    if (scc == 1)
    {
        puts("0");
        return;
    }
    int ret1 = 0,ret2 = 0;
    for (int i = 0 ; i < tot ; i++)
    {
        int v = Belong[edge[i].v];
        int u = Belong[edge[i].u];
        if (u == v) continue;
        degin[v]++;
        degout[u]++;
    }
    for (int i = 1 ; i <= scc ; i++)
    {
        if (degin[i] == 0) ret1++;
        if (degout[i] == 0) ret2++;
    }
    printf("%d\n",max(ret1,ret2));
}

int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&N,&M);
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797);
        }
        deal();
    }
    return 0;
}
View Code

HDU 3836 Equivalent Sets

与上题一样

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
const int MAXN = 200010;
const int MAXM = 500010;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,next;
    int w;
}edge[MAXM];
int N,M;
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int scc;
bool Instack[MAXN];
int degin[MAXN],degout[MAXN];
int num[MAXN];

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (!DFN[v])
        {
            Tarjan(v);
            if (Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if (Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }while (v != u);
    }
}

void deal()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    top = Index = scc = 0;
    memset(num,0,sizeof(num));
    memset(degin,0,sizeof(degin));
    memset(degout,0,sizeof(degout));
    for (int i = 1 ; i <= N ; i++)
    {
        if (!DFN[i]) Tarjan(i);
    }
    if (scc == 1)
    {
        puts("0");
        return;
    }
    int ret1 = 0,ret2 = 0;
    for (int i = 0 ; i < tot ; i++)
    {
        int v = Belong[edge[i].v];
        int u = Belong[edge[i].u];
        if (u == v) continue;
        degin[v]++;
        degout[u]++;
    }
    for (int i = 1 ; i <= scc ; i++)
    {
        if (degin[i] == 0) ret1++;
        if (degout[i] == 0) ret2++;
    }
    printf("%d\n",max(ret1,ret2));
}

int main()
{
    int T;
    while(scanf("%d%d",&N,&M) != EOF)
    {
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797);
        }
        deal();
    }
    return 0;
}
View Code

HDU 1827 Summer Holiday

强连通缩点，统计入度为0的就是要通知的人，对于每一个强连通分量只需要通知里面代价最小的那个更新答案即可。水题

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
const int MAXN = 1010;
const int MAXM = 2010;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,next;
    int w;
}edge[MAXM];
int N,M;
int ret;
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int scc;
bool Instack[MAXN];
int degin[MAXN],degout[MAXN];
int num[MAXN];
bool flag[MAXN];
int val[MAXN];

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (!DFN[v])
        {
            Tarjan(v);
            if (Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if (Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }while (v != u);
    }
}


void calcu()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    Index = top = scc = 0;
    int ans = 0,ret = 0;
    memset(flag,false,sizeof(flag));
    memset(degin,0,sizeof(degin));
    memset(degout,0,sizeof(degout));
    for (int i = 1 ; i <= N ; i++)
    {
        if (!DFN[i]) Tarjan(i);
    }
    for (int i = 0 ; i < tot ; i++)
    {
        int u = Belong[edge[i].u];
        int v = Belong[edge[i].v];
        if (u == v) continue;
        degin[v]++;
        degout[u]++;
    }
    for (int i = 1 ; i <= scc ; i++)
    {
        if (degin[i] == 0)
        {
            ans++;
            int tmp = INF;
            for (int j = 1 ; j <= N ; j++)
            {
                if (Belong[j] == i)
                    tmp = min(tmp,val[j]);
            }
            ret += tmp;
        }
    }
    
    printf("%d %d\n",ans,ret);
}

int main()
{
    while (scanf("%d%d",&N,&M) != EOF)
    {
        for (int i = 1 ; i <= N ; i++)scanf("%d",&val[i]);
        init();
        for (int i = 1 ; i <= M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797);
        }
        calcu();
    }
    return 0;
}
View Code

HDU 3072 Intelligence System

给了一个含有 n(0

问，从给定的节点向其他所有的点通信，所花费的最小代价是多少

先对原图缩点，形成一个 DAG，给的那个定点显然是 DAG 中入度为 0 的点，并且入度为 0 的点肯定只有一个（根据题目的意思）

每个顶点(除了那个定点)必定只有一个入点，那么，对于每个顶点，完全可以选择代价最小的那条入点，贪心的找即可

做了好久忘了咋做的了。上面你的题解是复制的。解法是一样的具体看代码。

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
const int MAXN = 50010;
const int MAXM = 100010;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,next;
    int w;
}edge[MAXM];
int N,M;
int ret;
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int scc;
bool Instack[MAXN];
int degin[MAXN],degout[MAXN];
int num[MAXN];
bool flag[MAXN];
int val[MAXN];

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (!DFN[v])
        {
            Tarjan(v);
            if (Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if (Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }while (v != u);
    }
}


void calcu()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    memset(degin,0,sizeof(degin));
    memset(degout,0,sizeof(degout));
    Index = top = scc = 0;
    for (int i = 0 ; i < N ; i++)
    {
        if (!DFN[i]) Tarjan(i);
    }
    memset(val,0x3f,sizeof(val));
    for (int i = 0 ; i < tot ; i++)
    {
        int u = Belong[edge[i].u];
        int v = Belong[edge[i].v];
        if (u == v) continue;
        val[v] = min(val[v] ,edge[i].w);
    //    printf("%d %d %d\n",v,val[v],edge[i].w);
        //printf("%d\n",edge[i].w);
    }
    LL ret = 0;
    for (int i = 1 ; i <= scc ; i++)
        ret += 1LL * val[i];
    printf("%lld\n",ret - INF);
}

int main()
{
    while (scanf("%d%d",&N,&M) != EOF)
    {
        init();
        int u,v,w;
        for (int i = 0 ; i < M ; i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
        }
        calcu();
    }
    return 0;
    
}
View Code

HDU 3639 Hawk-and-Chicken

有 n(2<=n<=5000) 个人，m(0

需要注意的是 support 是可以传递的，比如：A support B && B support C，那么，C 得到的 support 是 2

做法：强连通缩点，出度为0的点就是我们要的可能的最大support。为什么代码里是入度，我记得要处理出这个连通分量里的点是什么。而正向处理是比较麻烦的。

所以变成建反图，从入度为0点处理

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
const int MAXN = 5010;
const int MAXM = 60010;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,next;
    int w;
}edge[MAXM];
int N,M;
int ret;
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int scc;
bool Instack[MAXN];
int degin[MAXN],degout[MAXN];
int num[MAXN];
bool flag[MAXN];
int val[MAXN];

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (!DFN[v])
        {
            Tarjan(v);
            if (Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if (Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }while (v != u);
    }
}

vector<int>G[MAXN];
int sum;
bool vis[MAXN];

void dfs(int u)
{
    vis[u] = true;
    sum += num[u];
    for (int i = 0 ; i < (int)G[u].size() ; i++)
    {
        int v = G[u][i];
        if (vis[v]) continue;
        dfs(v);
    }
}


vector<int>ans;
int res[MAXN];
void calcu(int kase)
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    memset(res,-1,sizeof(res));
    memset(num,0,sizeof(num));
    top = Index = scc = 0;
    for (int i = 0 ; i < N ; i++)
    {
        if (!DFN[i]) Tarjan(i);
    }
    memset(degin,0,sizeof(degin));
    memset(degout,0,sizeof(degout));
    for (int i = 0 ; i <= scc ; i++) G[i].clear();
    for (int i = 0 ; i < tot ; i++)
    {
        int u = Belong[edge[i].u];
        int v = Belong[edge[i].v];
        if (u == v) continue;
        G[v].push_back(u);
        degin[u]++;
        degout[v]++;
    //    printf("%d %d\n",v,u);
    }
    int ret = 0;
    for (int i = 1 ; i <= scc ; i++)
    {
        if (degin[i] == 0)
        {
            sum = 0;
            memset(vis,false,sizeof(vis));
            dfs(i);
            res[i] = sum;
            if (sum > ret)
            {
                ret = sum;
            }
        }
    }
    //cout << ret << endl;
    ans.clear();
    for (int i = 0 ; i < N ; i++)
    {
        if (res[Belong[i]] == ret)
        {
            ans.push_back(i);
        }
    }
    printf("Case %d: %d\n",kase++,ret - 1);
    for (int i = 0 ; i < (int)ans.size() ; i++)
    {
        printf("%d%c",ans[i],i == ans.size() - 1 ? '\n' : ' ');
    }
}

int main()
{
    int kase = 1,T;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&N,&M);
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797);
        }
        calcu(kase++);
    }
    return 0;
}
View Code

HDU 3594 Cactus

仙人掌图+tarjan

我看了别人的题解弄的。代码里有解释和别人的题解链接

/*
题目大意：给你一个图，让你判断他是不是仙人掌图。

仙人掌图的条件是：

1、是强连通图。

2、每条边在仙人掌图中只属于一个强连通分量。

仙人掌图介绍   -->  http://files.cnblogs.com/ambition/cactus_solution.pdf

解题思路：

1、首先得先熟练掌握塔尖tarjan算法的应用。

2、必须了解仙人掌图的三个性质：

（1）.仙人掌dfs图中不能有横向边，简单的理解为每个点只能出现在一个强联通分量中。

（2）.low[v]*/

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
const int MAXN = 20010;
const int MAXM = 60010;
const int INF = 0x3f3f3f3f;
int fa[MAXN];
int Find(int x) {
      return x == fa[x] ? x : fa[x] = Find(fa[x]);}
struct Edge
{
    int u,v,next;
    int w;
}edge[MAXM];
int N,M;
int ret;
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int scc;
bool Instack[MAXN];
int degin[MAXN],degout[MAXN];
int num[MAXN];

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

bool flag;
void Tarjan(int u)
{
    int v;
    int cnt = 0;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (!DFN[v])
        {
            Tarjan(v);
            if (Low[v] > DFN[u]) flag = false;;
            if (Low[v] < DFN[u]) cnt++;
            if (cnt >= 2) flag = false;
            if (Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if (Instack[v])
        {
            Low[u] = min(Low[u],DFN[v]);
            cnt++;
            if (cnt >= 2) flag = false;
        }
    }
    if (Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }while (v != u);
    }
}


bool calcu()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    top = Index = scc = 0;
    flag = true;
    for (int i = 0 ; i < N ; i++)
    {
        if (!DFN[i]) Tarjan(i);
    }
//    for (int i = 0 ; i < N ; i++) printf("%d ",Belong[i]); putchar('\n');
//    printf("%d\n",scc);
    if (scc != 1) return false;
    return flag;
}

int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d",&N);
        init();
        int u,v;
        while (scanf("%d%d",&u,&v) != EOF)
        {
            if (u == 0 && v == 0) break;
            add_edge(u,v,9797);
        }
        if (calcu()) puts("YES");
        else puts("NO");
    }
    return 0;
}
View Code

HDU 2242 考研路茫茫――空调教室

枚举桥然后处理处每个点孩子的总数直接做就行

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 20010;
const int MAXM = 200010;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,w;
    int next;
    int id;
    bool cut;
};
Edge edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
bool Instack[MAXN];
bool cut[MAXN];
int num[MAXN];
int add_block[MAXN],N,M;
int bridge,block;
int son[MAXN],val[MAXN];
int sum;
vector<int>G[MAXN];
bool vis[MAXN];
int dep[MAXN];
int ret;

void init()
{
    memset(head,-1,sizeof(head));
    tot = 0;
}

void add_edge(int u,int v,int id,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].id = id;
    edge[tot].next = head[u];
    edge[tot].cut = false;
    head[u] = tot++;
}

void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        v = edge[i].v;
        if (!DFN[v])
        {
            Tarjan(v,edge[i].id);
            if (Low[u] > Low[v]) Low[u] = Low[v];
            if (Low[v] > DFN[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i ^ 1].cut = true;
            }
        }
        else if (DFN[v] < DFN[u] && edge[i].id != pre)
            Low[u] = min(Low[u],DFN[v]);
    }
    if (Low[u] == DFN[u])
    {
        block++;
        do
        {
            v = Stack[--top];
            Instack[v] = true;
            Belong[v] = block;
            son[block] += val[v];
        }while (v != u);
    }
}




void dfs(int u,int fa)
{
    vis[u] = true;
    son[u] = num[u];
    for (int i = 0 ; i < (int)G[u].size() ; i++)
    {
        int v = G[u][i];
        if (v == fa || vis[v]) continue;
        dep[v] = dep[u] + 1;
        dfs(v,u);
        son[u] += son[v];
    }
}

void calcu()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    memset(num,0,sizeof(num));
    Index = top = block = 0;
    for (int i = 0 ; i < N ; i++)
    {
        if (!DFN[i]) Tarjan(i,-1);
    }
//    for (int i = 0 ; i < N ; i++) printf("%d\n",Belong[i]);
    for (int i = 0 ; i < N ; i++) num[Belong[i]] += val[i];
//    for (int i = 1 ; i <= block ; i++) printf("%d ",num[i]); putchar('\n');
    if (block == 1) 
    {
        puts("impossible");
        return;
    }
    for (int i = 0 ; i <= block ; i++) G[i].clear();
    for (int i = 0 ; i < tot ; i++)
    {
        if (edge[i].cut)
        {
            int u = Belong[edge[i].u];
            int v = Belong[edge[i].v];
            G[u].push_back(v);
            G[v].push_back(u);
        }
    }
    dep[1] = 0;
    memset(vis,false,sizeof(vis));
    memset(son,0,sizeof(son));
    dfs(1,-1);
//    for (int i = 1 ; i <= block ; i++) printf("%d ",son[i]); putchar('\n');
    int ret = INF;
    //printf("%d\n",sum);
    for (int i = 0 ; i < tot ; i++)
    {
        if (edge[i].cut)
        {
            int u = Belong[edge[i].u];
            int v = Belong[edge[i].v];
            if (dep[u] < dep[v]) 
            {
                ret = min(ret,abs(sum - 2 * son[v]));
            }
            else
            {
                ret = min(ret,abs(sum - 2 * son[u]));
            }
        }
    }
    printf("%d\n",ret);
}

int main()
{
    while (scanf("%d%d",&N,&M) != EOF)
    {
        sum = 0;
        for (int i = 0 ; i < N ; i++) scanf("%d",&val[i]);
        for (int i = 0 ; i < N ; i++) sum += val[i];
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,i + 1,9797);
            add_edge(v,u,i + 1,9797);
        }
        calcu();
    }
    return 0;
}
View Code

HDU 2460 Network

a数组记得是表示以该点为桥边的较深点的桥是否已经被删除过

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 100010;
const int MAXM = 400010;
struct Edge
{
    int u,v,w;
    int next;
    int id;
    bool cut;
}edge[MAXM];
int head[MAXN],tot;
int N,M;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int block;
bool Instack[MAXN];
int bridge;

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w,int id)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].id = id;
    edge[tot].cut = false;
    edge[tot].next = head[u];
    head[u] =tot++;
}

void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    int son = 0;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        v = edge[i].v;
        if (!DFN[v])
        {
            son++;
            Tarjan(v,edge[i].id);
            if (Low[u] > Low[v]) Low[u] = Low[v];
            if (Low[v] > DFN[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i ^ 1].cut = true;
            }
        }
        else if (DFN[v] < DFN[u] && edge[i].id != pre)
            Low[u] = min(Low[u],DFN[v]);
    }
    if (Low[u] == DFN[u])
    {
        block++;
        do
        {
            v = Stack[--top];
            Instack[v] = true;
            Belong[v] = block;
        }while (v != u);
    }
}

vector<int>vec[MAXN];
int father[MAXN],dep[MAXN],a[MAXN];
void LCA_bfs(int root)
{
    memset(dep,-1,sizeof(dep));
    dep[root] = 0;
    a[root] = 0;
    father[root] = -1;
    queue<int>q;
    q.push(root);
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        for (int i = 0 ; i < (int)vec[u].size() ; i++)
        {
            int v = vec[u][i];
            if (dep[v] != -1) continue;
            dep[v] = dep[u] + 1;
            a[v] = 1;
            father[v] = u;
            q.push(v);
        }
    }
}

int ret;
void lca(int u,int v)
{
    if (dep[u] > dep[v]) swap(u,v);
    while (dep[u] < dep[v])
    {
        if (a[v])
        {
            ret--;
            a[v] = 0;
        }
        v = father[v];
    }
    while (u != v)
    {
        if (a[u])
        {
            ret--;
            a[u] = 0;
        }
        if (a[v])
        {
            ret--;
            a[v] = 0;
        }
        u = father[u];
        v = father[v];
    }
}

void calcu(int N)
{
    memset(Instack,false,sizeof(Instack));
    memset(DFN,0,sizeof(DFN));
    Index = top = block = 0;
    bridge = 0;
    for (int i = 1 ; i <= N ; i++)
        if (!DFN[i]) Tarjan(i,-1);
    for (int i = 1 ; i <= N ; i++)
        vec[i].clear();
    for (int u = 1 ; u <= N ; u++)
    {
        for (int i = head[u] ; i != -1 ; i = edge[i].next)
        {
            if (edge[i].cut == false) continue;
            int v = edge[i].v;
            vec[Belong[u]].push_back(Belong[v]);
            vec[Belong[v]].push_back(Belong[u]);
        }
    }
   // printf("%d\n",bridge);
    LCA_bfs(1);
    ret = block - 1;
    int Q;
    scanf("%d",&Q);
    while (Q--)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        lca(Belong[u],Belong[v]);
        printf("%d\n",ret);
    }
    putchar('\n');
}

int main()
{
   // freopen("sample.txt","r",stdin);
    int kase = 1;
    while (scanf("%d%d",&N,&M) != EOF)
    {
        if (N == 0 && M == 0) break;
        printf("Case %d:\n",kase++);
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797,i);
            add_edge(v,u,9797,i);
        }
        calcu(N);
    }
    return 0;
}
View Code

HDU 3849 By Recognizing These Guys, We Find Social Networks Useful

读完提就会做。

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
const int MAXN = 10010;
const int MAXM = 200010;
const int INF = 0x3f3f3f3f;
int N,M;
struct Edge
{
    int u,v,w;
    int next;
   // int id;
    bool cut;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int block;
bool Instack[MAXN];
int bridge;

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w,int id = 9797)
{
    edge[tot].u = u;
    edge[tot].v = v;
   // edge[tot].id = id;
    edge[tot].cut = false;
    edge[tot].next = head[u];
    head[u] =tot++;
}

void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Instack[u] = true;
    Stack[top++]= u;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (v == pre) continue;
        if (!DFN[v])
        {
            Tarjan(v,u);
            if (Low[u] > Low[v]) Low[u] = Low[v];
            if (Low[v] > DFN[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i ^ 1].cut = true;
            }
        }
        else if (Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u])
    {
        block++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = block;
        }while (u != v);
    }
}

map<string,int>mp;
map<int,string>res;

void calcu()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    Index = top = block = 0;
    bridge = 0;
    Tarjan(1,1);
    for (int i = 1 ; i <= N ; i++)
    {
        if (!DFN[i])
        {
            puts("0");
            return;
        }
    }
    printf("%d\n",bridge);
    for (int i = 0 ; i < tot ; i += 2)
    {
        if (edge[i].cut == false) continue;
        //printf("%s %s\n",res[edge[i].u],res[edge[i].v]);
        cout << res[edge[i].u] << " " << res[edge[i].v] << endl;
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&N,&M);
        init();
        mp.clear();
        res.clear();
        int cas = 1;
        for (int i = 1 ; i <= M ; i++)
        {
            int u,v;
            char src[50],tag[50];
            scanf("%s%s",src,tag);
            if (!mp[src]) 
            {
                res[cas] = src;
                mp[src] = cas++;
            }
            if (!mp[tag]) 
            {
                res[cas] = tag;
                mp[tag] = cas++;
            }
            u = mp[src];
            v = mp[tag];
            add_edge(u,v,9797);
            add_edge(v,u,9797);
        }
        calcu();
    }
    return 0;
}
View Code

HDU 3896  Greatest TC

搜了题解做的。代码里有我搜的题解的解析。太弱了orz

/*
给出一个无向图，询问两个点在删去一条边或者一个点以后能否到达。
 
生成一颗dfs树，然后记录dfn[]、low[]、final[]、deep[]。Final表示离开这个节点的时间。
对于边的询问，询问的节点是a,b，设这个边为g1-g2，其中deep[g1]>deep[g2]。
1． a在g1的子树内，b也在g1的子树内，那么a、b可以到达。
2． a不在g1的子树内，b也不在g1的子树内，那么a、b可以到达。
3． 不妨假设a在g1的子树内，b不在g1的子树内，则判断low[g1]是否≤dfn[g2]。如果是的话，那么a、b可以到达。
4． 其他情况下不能到达。
对于点的询问，询问的节点是a,b，设这个点为g1：
1． 如果a，b都不在g1的子树内。则可行
2． 如果a，b有一个在g1的子树内（设为a），求出在a-g1路径上的倒数第二个点k，如果low[k] < dfn[g1]则可行
3． 如果a，b都在g1的子树内。求出在a-g1路径上的倒数第二个点k1，在b-g1路径上的倒数第二个点k2，判断是否两者的low都= dfn[g] 且 final[a] <= final[g]
开始怎么都a不了。后然问了学长才发现对于点询问如果a,b,都在g1子树中，如果k1=k2那么直接输出yes好了。。wa了N多次。。
*/

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 100010;
const int MAXM = 1000010;
const int INF = 0x3f3f3f3f;
int N,M;
struct Edge
{
    int u,v,w;
    int next;
   // int id;
    bool cut;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int dep[MAXN];
int leave[MAXN];
int fa[MAXN];
int block;
bool vis[MAXM];
bool Instack[MAXN];
int bridge;

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w,int id = 9797)
{
    edge[tot].u = u;
    edge[tot].v = v;
   // edge[tot].id = id;
    edge[tot].cut = false;
    edge[tot].next = head[u];
    head[u] =tot++;
}

void Tarjan(int u,int pre,int depth)
{
    Low[u] = DFN[u] = ++Index;
    dep[u] = depth ;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        if (vis[i]) continue;
        vis[i] = vis[i ^ 1] = true;
        int v = edge[i].v;
        if (!DFN[v])
        {
            Tarjan(v,u,depth + 1);
            fa[v] = u;
            Low[u] = min(Low[u],Low[v]);
        }
        else
            Low[u] = min(Low[u],DFN[v]);
    }
    leave[u] = Index;
}

void calcu()
{
    memset(vis,false,sizeof(vis));
    memset(DFN,0,sizeof(DFN));
    memset(fa,-1,sizeof(fa));
    Index = top = block = 0;
    bridge = 0;
    for (int i = 1 ; i <= N ; i++)
    {
        if (!DFN[i]) Tarjan(i,i,0);
    }
}

int main()
{
    while (scanf("%d%d",&N,&M) != EOF)
    {
    //    printf("N = %d M = %d\n",N,M);
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797);
            add_edge(v,u,9797);
        }
        calcu();
        int Q;
        scanf("%d",&Q);
    //    printf("Q = %d\n",Q);
        while (Q--)
        {
            int op;
            scanf("%d",&op);
            if (op == 1)
            {
                int u,v,g1,g2;
                scanf("%d%d%d%d",&u,&v,&g1,&g2);
                bool flag1 = false,flag2 = false;
                if (dep[g1] < dep[g2]) swap(g1,g2);
                if (DFN[u] >= DFN[g1] && leave[u] <= leave[g1]) flag1 = true;
                if (DFN[v] >= DFN[g1] && leave[v] <= leave[g1]) flag2 = true;
                if ((flag1 && flag2) || (!flag1 && !flag2))
                {
                    puts("yes");
                }
                else
                {
                    if (Low[g1] <= DFN[g2])
                    {
                        puts("yes");
                    }
                    else
                    {
                        puts("no");
                    }
                }
            }
            else
            {
                int u,v,g1;
                scanf("%d%d%d",&u,&v,&g1);
                if (u == g1 || v == g1)
                {
                    puts("no");
                    continue;
                }
                bool flag1 = false,flag2 = false;
                if (DFN[u] >= DFN[g1] && leave[u] <= leave[g1]) flag1 = true;
                if (DFN[v] >= DFN[g1] && leave[v] <= leave[g1]) flag2 = true;
                if (!flag1 && !flag2)
                {
                    puts("yes");
                    continue;
                }
                if (flag1 && !flag2)
                {
                    int x = u;
                    while (fa[x] != g1)
                        x = fa[x];
                    if (Low[x] < DFN[g1])
                        puts("yes");
                    else puts("no");
                    continue;
                }
                if (flag2 && !flag1)
                {
                    int y = v;
                    while (fa[y] != g1)
                        y = fa[y];
                    if (Low[y] < DFN[g1])
                        puts("yes");
                    else puts("no");
                    continue;
                }
                if (flag1 && flag2)
                {
                    int x = u;
                    while (fa[x] != g1) x = fa[x];
                    int y = v;
                    while (fa[y] != g1) y = fa[y];
                    if (x == y)
                    {
                        puts("yes");
                        continue;
                    }
                    if (Low[x] < DFN[g1] && Low[y] < DFN[g1])
                        puts("yes");
                    else
                         puts("no");
                     continue;
                }
                puts("no");
            }
        }
    }
    return 0;
}
View Code

HDU 4005 The war

比较难的题目。所点后从最小桥边两个点为起点DFS，找到次小值为答案

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 20010;
const int MAXM = MAXN * 10;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,next;
    int w,id;
    bool cut;
    friend bool operator < (const Edge &a,const Edge &b)
    {
        return a.w < b.w;
    }
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
bool Instack[MAXN];
bool cut[MAXN];
int add_block[MAXN];
int bridge,block;
int N,M;

void init()
{
    memset(head,-1,sizeof(head));
    tot = 0;
}

void add_edge(int u,int v,int w,int id)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].id = id;
    edge[tot].next = head[u];
    edge[tot].cut = false;
    head[u] = tot++;
}

void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    int son = 0;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        v = edge[i].v;
        if (edge[i].id == pre) continue;
        if (!DFN[v])
        {
            son++;
            Tarjan(v,edge[i].id);
            if (Low[u] > Low[v]) Low[u] = Low[v];
            if (Low[v] > DFN[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i ^ 1].cut = true;
            }
        }
        else if (DFN[v] < DFN[u] && edge[i].id != pre)
            Low[u] = min(Low[u],DFN[v]);
    }
    if (Low[u] == DFN[u])
    {
        block++;
        do
        {
            v = Stack[--top];
            Instack[v] = true;
            Belong[v] = block;
        }while (v != u);
    }
}

vectorG[MAXN];
int ret;
int dfs(int u,int fa)
{
    int fir = INF,sec = INF,tmp,val;
    for (int i = 0 ; i < (int)G[u].size() ; i++)
    {
        int v = G[u][i].v;
        if (v == fa) continue;
        val = G[u][i].w;
        sec = min(sec,val);
        tmp = dfs(v,u);
        sec = min(sec,tmp);
        if (fir > sec) swap(fir,sec);
    }
    ret = min(ret,sec);
    return fir;
}

void calcu()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    Index = bridge = block = 0;
    top = 0;
    for (int i = 1 ; i <= N ; i++)
    {
        if (!DFN[i]) Tarjan(i,-1);
    }
  //  printf("%d\n",block);
    if (block == 1)
    {
        puts("-1");
        return;
    }
    for (int i = 0 ; i <= N ; i++) G[i].clear();
    int posu = -1,val = INF,posv = -1;
    for (int i = 0 ; i < tot ; i++)
    {
        if (edge[i].cut)
        {
            int u = Belong[edge[i].u];
            int v = Belong[edge[i].v];
            Edge tmp;
            tmp.u = u;
            tmp.v = v;
            tmp.w = edge[i].w;
            tmp.cut = true;
            G[u].push_back(tmp);
            if (edge[i].w < val)
            {
                posu = u;
                val = edge[i].w;
                posv = v;
            }
        }
    }
    for (int i = 1 ; i <= block ; i++) sort(G[i].begin() ,G[i].end());
    /*for (int i = 1 ; i <= block ; i++)
    {
        printf("%d :\n",i);
        for (int j = 0 ; j <(int)G[i].size() ; j++)
        {
            printf("%d ",G[i][j].v);
        }
        putchar('\n');
    }*/
    //printf("%d %d\n",posu,posv);
    if (posu == -1 || posv == -1)
    {
        puts("-1");
        return;
    }
    ret = INF;
    dfs(posu,posv);
    dfs(posv,posu);
    printf("%d\n",ret >= INF ? -1 : ret);
}

int main()
{
    while (scanf("%d%d",&N,&M) != EOF)
    {
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w,i + 1);
            add_edge(v,u,w,i + 1);
        }
        calcu();
    }
    return 0;
}
View Code

HDU 3394 Railway

做了这么多题这是第一道点连通分量的题目。可以的。。一直WA以为是边联通就对。。(⊙﹏⊙)b

注意割点可以属于多个双连通分量

//注意这里是点双联通而且又一个重要的。不可以直接TARJAN后处理Belong然后在处理多余边。一定不可以
//一定要在TARJAN处理处一个联通快就直接更新答案、原因就是这里的是点双联通
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626 
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 20010;
const int MAXM = 200010;
const int INF = 0x3f3f3f3f; 
int N,M;
struct Edge
{
    int u,v,w;
    int next;
   // int id;
    bool cut;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int cnt[MAXN];
int block;
bool Instack[MAXN];
int num[MAXN];
bool vis[MAXN];
vector<int>res;
int bridge,ret;

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

stackS;

void add_edge(int u,int v,int w,int id = 9797)
{
    edge[tot].u = u;
    edge[tot].v = v;
   // edge[tot].id = id;
    edge[tot].cut = false;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void update()
{
    memset(vis,false,sizeof(vis));
    int sum = 0;
    for (int i = 0 ; i < (int)res.size() ; i++)
    {
        int u = res[i];
        vis[u] = true;
    }
    for (int i = 0 ; i <(int)res.size() ; i++)
    {
        int u =res[i];
        for (int i = head[u] ; i != -1 ; i = edge[i].next)
        {
            int v = edge[i].v;
            if (vis[v]) sum++;
        }
    }
    sum /= 2;
    if (sum > res.size()) ret += sum;
}

void Tarjan(int u,int fa)
{
    Low[u] = DFN[u] = ++Index;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (v == fa) continue;
        Edge tmp;
        tmp.u = u;
        tmp.v = v;
        if (!DFN[v])
        {
            S.push(tmp);
            Tarjan(v,u);
            Low[u] = min(Low[u],Low[v]);
            if(Low[v] >= DFN[u])//u是割点
            {
                if(Low[v] > DFN[u])
                {
                    bridge++;
                    edge[i].cut = true;
                    edge[i ^ 1].cut = true;
                }
                block++;
                res.clear();
                while(true)
                {
                    Edge x = S.top(); S.pop();
                    if(Belong[x.u] != block)
                    {
                           res.push_back(x.u);
                           Belong[x.u] = block;
                    }
                    if(Belong[x.v] != block)
                    {
                        res.push_back(x.v);
                        Belong[x.v] = block;
                    }
                    if(x.u==u && x.v==v) break;
                }
                update();
            }
        }
        else if(DFN[v] < DFN[u] && v != fa) 
        {
            S.push(tmp);
            Low[u] = min(Low[u],DFN[v]);
        }
    }
}

void calcu()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    memset(num,0,sizeof(num));
    memset(Belong,0,sizeof(Belong));
    Index = top = block = bridge = 0;
    ret = 0;
    for (int i = 0 ; i < N ; i++)
    {
        if (!DFN[i]) Tarjan(i,-1);
    }
    printf("%d %d\n",bridge,ret);
}

int main()
{
    while (scanf("%d%d",&N,&M) != EOF)
    {
        if (N == 0 && M == 0) break;
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797);
            add_edge(v,u,9797);
        }
        calcu();
    }
    return 0;
}
View Code

HDU 2874 Connections between cities

倍增无难度

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626 
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 10010;
const int MAXM = MAXN * 4;
const int INF = 0x3f3f3f3f;
int FA[MAXN];
int Find(int x) {
      return x == FA[x] ? x : FA[x] = Find(FA[x]);}
struct Edge
{
    int u,v,w;
    int next;
}edge[MAXM];
int head[MAXN],tot;
int N,M;

void init()
{
    memset(head,-1,sizeof(head));
    tot = 0;
    for (int i = 0 ; i <= N ; i++) FA[i] = i;
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

int dep[MAXN],fa[MAXN],cost[MAXN];
int sumcost[MAXN][20],anc[MAXN][20];
bool vis[MAXN];

void bfs(int root)
{
    queue<int>q;
    q.push(root);
    vis[root] = true;
    fa[root] = -1;
    dep[root] = 0;
    cost[root] = 0;
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        for (int i = head[u] ; i != -1 ; i = edge[i].next)
        {
            int v = edge[i].v;
            if (vis[v]) continue;
            dep[v] = dep[u] + 1;
            cost[v] = edge[i].w;
            fa[v] = u;
            vis[v] = true;
            q.push(v);
        }
    }
}

void preprocess()
{
    memset(sumcost,0,sizeof(sumcost));
    for (int i = 1 ; i <= N ; i++)
    {
        anc[i][0] = fa[i];
        sumcost[i][0] = cost[i];
        for (int j = 1 ; (1 << j) <= N ; j++) anc[i][j] = -1;
    }
    for (int j = 1 ; (1 << j) <= N ; j++)
    {
        for (int i = 1 ; i <= N ; i++)
        {
            if (anc[i][j - 1] != -1)
            {
                int a = anc[i][j - 1];
                anc[i][j] = anc[a][j - 1];
                sumcost[i][j] = sumcost[i][j - 1] + sumcost[a][j - 1];
            }
        }
    }
}


int query(int p,int q)
{
    int tmp,log;
    if (dep[p] < dep[q]) swap(p,q);
    for (log = 1 ; (1 << log) <= dep[p] ; log++); log--;
    int ans = 0;
    for (int i = log ; i >= 0 ; i--)
    {
        if (dep[p] - (1 << i) >= dep[q]) 
        {
            ans += sumcost[p][i];
            p = anc[p][i];
        }
    }
    if (p == q) return ans;
    for (int i = log ; i >= 0 ; i--)
    {
        if (anc[p][i] != -1 && anc[p][i] != anc[q][i])
        {
            ans += sumcost[p][i]; p = anc[p][i];
            ans += sumcost[q][i]; q = anc[q][i];
        }
    }
    ans += cost[p];
    ans += cost[q];
    return ans;
}

int main()
{
    int M,C;
    while (scanf("%d%d%d",&N,&M,&C) != EOF)
    {
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
            add_edge(v,u,w);
            int fu = Find(u);
            int fv = Find(v);
            if (fu != fv) FA[fu] = fv;
        }
        memset(vis,false,sizeof(vis));
        for (int i = 1 ; i <= N ; i++) if (!vis[i])
            bfs(i);
        preprocess();
        while (C--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            int fu = Find(u);
            int fv = Find(v);
        //    printf("%d %d %d %d\n",u,v,fu,fv);
            if (fu == fv)
            {
                printf("%d\n",query(u,v));
            }
            else puts("Not connected");
        }
    }
    return 0;
}
View Code

HDU 3078 Network

直接暴力居然不会T。我也不知道为啥。

所以做法就是直接爆。修改就直接该。Nothing more

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626 
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 80010;
const int MAXM = 160010;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,w;
    int next;
}edge[MAXM];
int head[MAXN],tot;
int N,K;

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

int dep[MAXN],fa[MAXN],val[MAXN];
int anc[MAXN][20];
bool vis[MAXN];

int src[MAXN],cnt;
int cmp(const int &a,const int &b)
{
    return a > b;
}

void bfs(int root)
{
    memset(vis,false,sizeof(vis));
    queue<int>q;
    q.push(root);
    vis[root] = true;
    fa[root] = -1;
    dep[root] = 0;
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        for (int i = head[u] ; i != -1 ; i = edge[i].next)
        {
            int v = edge[i].v;
            if (vis[v]) continue;
            dep[v] = dep[u] + 1;
            fa[v] = u;
            vis[v] = true;
            q.push(v);
        }
    }
}

void preprocess()
{
    for (int i = 1 ; i <= N ; i++)
    {
        anc[i][0] = fa[i];
        for (int j = 1 ; (1 << j) <= N ; j++) anc[i][j] = -1;
    }
    for (int j = 1 ; (1 << j) <= N ; j++)
    {
        for (int i = 1 ; i <= N ; i++)
        {
            if (anc[i][j - 1] != -1)
            {
                int a = anc[i][j - 1];
                anc[i][j] = anc[a][j - 1];
            }
        }
    }
}


int query(int p,int q)
{
    int tmp,log;
    if (dep[p] < dep[q]) swap(p,q);
    for (log = 1 ; (1 << log) <= dep[p] ; log++); log--;
    for (int i = log ; i >= 0 ; i--)
    {
        if (dep[p] - (1 << i) >= dep[q]) 
        {
            p = anc[p][i];
        }
    }
    if (p == q) return p;
    for (int i = log ; i >= 0 ; i--)
    {
        if (anc[p][i] != -1 && anc[p][i] != anc[q][i])
        {
            p = anc[p][i];
            q = anc[q][i];
        }
    };
    return fa[p];
}

void update(int u,int ed)
{
    while (u != ed)
    {
        src[++cnt] = val[u];
        u = fa[u];
    }
}

void slove(int u,int v)
{
    int lca = query(u,v);
//    printf("%d %d %d\n",u,v,lca);
    cnt = 0;
    update(u,lca);
    update(v,lca);
    src[++cnt] = val[lca];
    if (cnt < K)
    {
        puts("invalid request!");
        return;
    }
    sort(src + 1,src + 1 + cnt,cmp);
    printf("%d\n",src[K]);
}

int main()
{
    int Q;
    while (scanf("%d%d",&N,&Q) != EOF)
    {
        init();
        for (int i = 1 ; i <= N ; i++) scanf("%d",&val[i]);
        for (int i = 1 ; i < N ; i++)
        {
            int u,v,w;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797);
            add_edge(v,u,9797);
        }
        bfs(1);
    //    printf("%d %d %d %d %d\n",fa[1],fa[2],fa[3],fa[4],fa[5]);
        preprocess();
        while (Q--)
        {
            int op;
            scanf("%d",&op);
            if (op == 0)
            {
                int u,cost;
                scanf("%d%d",&u,&cost);
                val[u] = cost;
            }
            else
            {
                K = op;
                int u,v;
                scanf("%d%d",&u,&v);
                slove(u,v);
            }
        }
    }
    return 0;
}
View Code

HDU 3830 Checkers

这题真的神。我醉了。完全抄的比人的代码。感觉如果比赛除了这题必然不会。。膜拜一下

题解看这里讲的非常详细

http://www.cnblogs.com/scau20110726/archive/2013/06/14/3135024.html

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
struct state
{
    LL x,y,z;
    LL dep;
}S,T;

inline bool cmp_state(const state &a,const state &b)
{
    if (a.x == b.x && a.y == b.y && a.z == b.z) return true;
    return false;
}

inline void makeorder(state &a)
{
    LL tmp[5];
    tmp[0] = a.x;
    tmp[1] = a.y;
    tmp[2] = a.z;
    sort(tmp,tmp + 3);
    a.x = tmp[0];
    a.y = tmp[1];
    a.z = tmp[2];
}

state Root(state &a)
{
    state tmp = a;
    tmp.dep = 0;
    LL dep = 0;
    while(abs(tmp.x - tmp.y) != abs(tmp.y - tmp.z))
    {
        LL len = abs(tmp.x - tmp.y);
        LL __len = abs(tmp.y- tmp.z);
        if(__len > len)
        {
            LL c = (__len - 1)/ len;
            dep += c;
            tmp.y += c * len;
            tmp.x += c * len;
        }
        else
        {
            LL c = (len - 1) / __len;
            dep += c;
            tmp.y -= c * __len;
            tmp.z -= c * __len;
        }
    }
    a.dep = dep;
    return tmp;
}

void update(state &a ,LL delta)
{
    LL cnt = 0;
    while(cnt < delta)
    {
        LL len = abs(a.x - a.y);
        LL __len = abs(a.y - a.z);
        LL k = abs(cnt - delta); //还差多少步
        if(len < __len)
        {
            LL c = (__len - 1) / len; //将要移动多少步
            LL Min = min(k , c);
            a.x += Min * len;
            a.y += Min * len;
            cnt += Min;
            if(Min == k) break;
        }
        else
        {
            LL c = (len - 1) / __len;
            LL Min = min(k , c);
            a.y -= Min * __len;
            a.z -= Min * __len;
            cnt += Min;
            if(Min == k) break;
        }
    }
    a.dep -= delta;
}

LL calcu()
{
    state tmpS,tmpT;
    LL low = 0,high = S.dep;
    while (low <= high)
    {
        LL mid = (low + high) / 2;
        LL delta = S.dep - mid;
        tmpS = S;
        tmpT = T;
        update(tmpS,delta);
        update(tmpT,delta);
        if (!cmp_state(tmpS,tmpT))  high = mid - 1;
        else low = mid + 1;
    }
    return 2 * (S.dep - high);
}

int main()
{
    while (scanf("%I64d%I64d%I64d",&S.x,&S.y,&S.z) != EOF)
    {
        scanf("%I64d%I64d%I64d",&T.x,&T.y,&T.z);
        S.dep = T.dep = 0;
        makeorder(S);
        makeorder(T);
        state rs = Root(S);
        state rt = Root(T);
        if (!cmp_state(rs,rt))
        {
            puts("NO");
            continue;
        }
        LL tmpr = abs(S.dep - T.dep);
     //   printf("%I64d %I64d %I64d\n",T.x,T.y,T.z);
        if (S.dep > T.dep) update(S,S.dep - T.dep);
        else update(T,T.dep - S.dep);
        LL ret = calcu();
        puts("YES");
        printf("%I64d\n",ret + tmpr);
    }
    return 0;
}
View Code

HDU 4338 Simple Path

很考验玛丽的一道题、具体怎么做的不太好说。看这里吧。他说的比较好。

就是通过割点。点双连通分量建树，然后树上的关系更新出答案，去重。割点要单独为1个点。

如果查询的点就是割点要选择单独割点为新点的那个店作为新图 。其余情况选择点双连通分量的那个店

这个非常详细 http://blog.csdn.net/julyana_lin/article/details/8128352

代码如下。有些中间调试没删掉。感觉此题比较考验玛丽。仔细看一下发现其实还是很容易些的，多一份写法可能更相似更愿意去看。

#pragma comment(linker, "/STACK:102400000,102400000")
#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {
      return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 100010;
const int MAXM = 400010;
const int INF = 0x3f3f3f3f;
int N,M;
struct Edge
{
    int u,v,w;
    int next;
   // int id;
    bool cut;
}edge[MAXM];
int head[MAXN],tot;

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

int Low[MAXN],DFN[MAXN];
bool cut[MAXN];
int Stack[MAXN];
int deep,top,bnum,root;
int Index,cas;
vector<int>block[MAXN];

void Tarjan(int u,int pre)
{
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    bool flag = false;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (v == pre && !flag)
        {
            flag = true;
            continue;
        }
        if (!DFN[v])
        {
            Tarjan(v,u);
            Low[u] = min(Low[u],Low[v]);
            if (Low[v] >= DFN[u])
            {
                if (pre == -1) root++;
                else cut[u] = true;
                int tmp;
                do
                {
                    tmp = Stack[--top];
                    block[bnum].push_back(tmp);
                }while (tmp != v);
                block[bnum].push_back(u);
                bnum++;
            }
        }
        else Low[u] = min(Low[u],DFN[v]);
    }
}

vector<int>G[MAXN];
int lab[MAXN];
int nb[MAXN];

void calcu()
{
    memset(cut,false,sizeof(cut));
    memset(DFN,0,sizeof(DFN));
    for (int i = 0 ; i <= N ; i++) G[i].clear();
    for (int i = 0 ; i <= N ; i++) block[i].clear();
    top = bnum = Index = 0;
    for (int i = 0 ; i < N ; i++)
    {
        if (!DFN[i])
        {
            root = 0;
            Tarjan(i,-1);
            if (root > 1) cut[i] = true;
        }
    }
    /*
    for (int i = 0 ; i < bnum ; i++)
    {
        for (int j = 0 ; j < (int)block[i].size() ; j++)
            printf("%d ",block[i][j]);
        putchar('\n');
    }*/

    memset(lab,-1,sizeof(lab));
    cas = 0;
    for (int i = 0 ; i < N ; i++)
    {
        if (cut[i])
        {
            lab[i] = cas;
            nb[cas] = 1;
            cas++;
        }
    }
    for (int i = 0 ; i < bnum ; i++)
    {
        for (int j = 0 ; j < (int)block[i].size() ; j++)
        {
            int v = block[i][j];
            if (cut[v])
            {
              //  printf("%d is cut\n",v);
                G[lab[v]].push_back(cas);
                G[cas].push_back(lab[v]);
            }
            else
                lab[v] = cas;
        }
        nb[cas] = block[i].size();
        cas++;
    }
   /* putchar('\n');
    for (int i = 0 ; i < N ; i++) printf("%d ",lab[i]);
    putchar('\n');
    for (int i = 0 ; i < cas ; i++)
    {
        for (int j = 0 ; j < (int)G[i].size() ; j++)
            printf("%d ",G[i][j]);
        putchar('\n');
    }
*/
}

int id[MAXN];
int dep[MAXN],fa[MAXN],cost[MAXN];
int anc[MAXN][20];
bool vis[MAXN];

void bfs(int root)
{
    cost[root] = nb[root];
    fa[root] = -1;
    dep[root] = 0;
    vis[root] = true;
    queue<int>q;
    q.push(root);
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        for (int i = 0 ; i < (int)G[u].size() ; i++)
        {
            int v = G[u][i];
            if (vis[v]) continue;
            vis[v] = true;
            dep[v] = dep[u] + 1;
            fa[v] = u;
            cost[v] = cost[u] + nb[v];
            q.push(v);
        }
    }
}

void preprecess()
{
    for (int i = 0 ; i < cas ; i++)
    {
        anc[i][0] = fa[i];
        for (int j = 1 ; (1 << j) < cas ; j++) anc[i][j] = -1;
    }
    for (int j = 1 ; (1 << j) < cas ; j++)
    {
        for (int i = 0 ; i < cas ; i++)
        {
            if (anc[i][j - 1] != -1)
            {
                int a = anc[i][j - 1];
                anc[i][j] = anc[a][j - 1];
            }
        }
    }
}

int query(int p,int q)
{
    int tmp,log;
    if (dep[p] < dep[q]) swap(p,q);
    for (log = 1 ; (1 << log) <= dep[p] ; log++); log--;
    for (int i = log ; i >= 0 ; i--)
    {
        if (dep[p] - (1 << i) >= dep[q])
            p = anc[p][i];
    }
    if (p == q)return p;
    for (int i = log ; i >= 0 ; i--)
    {
        if (anc[p][i] != -1 && anc[p][i] != anc[q][i])
        {
            p = anc[p][i];
            q = anc[q][i];
        }
    }
    return fa[p];
}

void col(int u,int type)
{
    id[u] = type;
    for (int i = 0 ; i < (int)G[u].size() ; i++)
    {
        int v = G[u][i];
        if (id[v] != -1) continue;
        col(v,type);
    }
}


int main()
{
    int kase = 1;
    while (scanf("%d%d",&N,&M) != EOF)
    {
        init();
        for (int i = 0 ; i < M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797);
            add_edge(v,u,9797);
        }
        calcu();
        memset(dep,0,sizeof(dep));
        memset(vis,false,sizeof(vis));
        memset(cost,0,sizeof(cost));
        for (int i = 0 ; i < cas ; i++)
            if (dep[i] == 0) bfs(i);
       // for (int i = 0 ; i < 4 ; i++)
       //     printf("%d %d %d %d\n",i,fa[i],dep[i],cost[i]);
        preprecess();
        int Q;
        memset(id,-1,sizeof(id));
        int step = 1;
        for (int i = 0 ; i < cas ; i++)
        {
            if (id[i] == -1)
            {
                col(i,step);
                step++;
            }
        }
        printf("Case #%d:\n",kase++);
        scanf("%d",&Q);
        while (Q--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            if (u == v)
            {
                printf("%d\n",N - 1);
                continue;
            }
            if (lab[u] == -1 || lab[v] == -1)
            {
                printf("%d\n",N);
                continue;
            }
            if (id[lab[u]] != id[lab[v]])
            {
                printf("%d\n",N);
                continue;
            }
            int realu = lab[u];
            int realv = lab[v];
            int lca = query(realu,realv);
          //  printf("%d %d %d %d %d\n",u,v,realu,realv,lca);
            int sum = cost[realu] + cost[realv] - 2 * cost[lca] + nb[lca];
            int len = dep[realu] + dep[realv] - 2 * dep[lca];
            printf("%d\n",N - (sum - len));
        }
        putchar('\n');
    }
    return 0;
}
View Code

FZU 1719 Spy network

在缩点入度为0的点里选择权最小的求和就是答案。比较容易

#include 
#include <set>
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {
       return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 5010;
const int MAXM = 10010;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int u,v,next;
    int w;
}edge[MAXM];
int N;
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Index,top;
int scc;
bool Instack[MAXN];
int degin[MAXN],degout[MAXN];
int num[MAXN];
int val[MAXN],M;
int MIN[MAXN];

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void add_edge(int u,int v,int w)
{
    edge[tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].v;
        if (!DFN[v])
        {
            Tarjan(v);
            if (Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if (Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }while (v != u);
    }
}

void calcu()
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    top = Index = scc = 0;
    memset(num,0,sizeof(num));
    for (int i = 1 ; i <= N ; i++)
    {
        if (!DFN[i]) Tarjan(i);
    }
    memset(degin,0,sizeof(degin));
    memset(degout,0,sizeof(degout));
    memset(MIN,0x3f,sizeof(MIN));
    for (int i = 1 ; i <= N ; i++)
    {
        MIN[Belong[i]] = min(MIN[Belong[i]],val[i]);
    }
    for (int i = 0 ; i < tot ; i++)
    {
        int u = Belong[edge[i].u];
        int v = Belong[edge[i].v];
        if(u == v) continue;
        degout[u]++;
        degin[v]++;
    }
    bool flag = false;
    for (int i = 1 ; i <= scc ; i++)
    {
        if (degin[i] == 0 && MIN[i] >= INF)
        {
            flag = true;
            break;
        }
    }
    if (flag)
    {
        puts("NO");
        int pos = - 1;
        for (int i = 1 ; i <= N ; i++)
            if (degin[Belong[i]] == 0 && MIN[Belong[i]] >= INF)
        {
            printf("%d\n",i);
            return;
        }
    }
    else
    {
        puts("YES");
        int ret = 0;
        for (int i = 1 ; i <= scc ; i++) if (degin[i] == 0) ret += MIN[i];
        printf("%d\n",ret);
    }
}

int main()
{
    while (scanf("%d",&N) != EOF)
    {
        init();
        int P;
        scanf("%d",&P);
        memset(val,0x3f,sizeof(val));
        for (int i = 1 ; i <= P ; i++)
        {
            int x,value;
            scanf("%d%d",&x,&value);
            val[x] = min(val[x],value);
        }
        int M;
        scanf("%d",&M);
        for (int i = 0 ; i < M ; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v,9797);
        }
        calcu();
    }
    return 0;
}
View Code

 

 
 

转载于:https://www.cnblogs.com/Commence/p/4860710.html

你可能感兴趣的:(数据结构与算法)

  • Java-后端程序员个人知识总结 金肴羽 java开发语言
    文章目录概要1.编程语言2.数据结构与算法3.数据库知识4.框架和库5.服务器管理6.网络知识7.版本控制8.测试9.安全知识10.系统设计11.编码规范与最佳实践12.持续学习和适应能力概要后端程序员，主要负责应用程序的逻辑、数据库交互、服务器配置以及应用的性能优化等。成为一名优秀的后台程序员，需要掌握以下技能：1.编程语言掌握至少一种后台编程语言JavaPythonHtmlJavaScript
  • 海量数据查找最大K个值：数据结构与算法的选择 星辰@Sea 数据结构Java数据结构
    在处理大数据集时，经常需要找到数据集中最大的K个元素，这样的需求在很多领域都有广泛应用，例如推荐系统中寻找评分最高的K个商品、数据分析中找出最重要的K个特征、搜索引擎中找到排名前K的结果等等。面对海量数据，传统的排序方法可能不再适用，因为它们通常具有较高的时间复杂度。因此，选择合适的数据结构和算法对于提高效率至关重要。本文将详细介绍如何在海量数据集中查找最大的K个值，探讨不同的数据结构与算法选择，
  • 22级数据结构与算法实验2——链表 “世有神明” 链表算法数据结构
    7-1两个有序链表序列的合并分数20全屏浏览题目切换布局作者DS课程组单位浙江大学已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。输入格式:输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。数字用空格间隔。输出格式:在一行中输出合并后新的非降序链表，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NU
  • 《数据结构与算法》知识点（四） 游戏原画设计
    第七章查找顺序查找、折半查找、索引查找、分块查找是静态查找，动态查找有二叉排序树查找，最优二叉树查找，键树查找，哈希表查找静态查找表顺序表的顺序查找：应用范围：顺序表或线性链表表示的表，表内元素之间无序。查找过程：从表的一端开始逐个进行记录的关键字和给定值的比较。顺序有序表的二分查找。平均查找时间(n+1)/nlog2(n+1)分块查找：将表分成几块，块内无序，块间有序，即前一块中的最大值小于后一
  • 数据结构与算法——7-6 列出连通集 (25分) 吃完有点累 数据结构与算法队列算法数据结构DFSBFS
    7-6列出连通集(25分)给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。输入格式:输入第1行给出2个整数N(0#includetypedefintVertexType;typedefintEdgeType;#defineMAXVEX100#defineINFINITY
  • 数据结构与算法 - 贪心算法 临界点oc 数据结构与算法贪心算法算法
    一、贪心例子贪心算法或贪婪算法的核心思想是：1.将寻找最优解的问题分为若干个步骤2.每一步骤都采用贪心原则，选取当前最优解3.因为没有考虑所有可能，局部最优的堆叠不一定让最终解最优贪心算法是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致结果是最好或最优的算法。这种算法通常用于求解优化问题，如最小生成树、背包问题等。贪心算法的应用：1.背包问题：给定一组物品和一个背包
  • Java数据结构与算法：动态规划之斐波那契数列 省赚客APP开发者@聚娃科技 java动态规划代理模式
    Java数据结构与算法：动态规划之斐波那契数列大家好，我是免费搭建查券返利机器人赚佣金就用微赚淘客系统3.0的小编。在这寒冷的季节里，让我们一同探讨Java中的动态规划，重点关注解决问题的经典代表之一——斐波那契数列。动态规划简介动态规划是一种解决问题的数学方法，通常用于优化递归算法。它通过将问题分解为子问题并保存它们的解，避免重复计算，从而提高算法效率。在动态规划的应用中，最常见的问题之一就是求
  • 【数据结构与算法 | 每日一题 | 力扣篇】 Vez'nan的幸福生活 leetcode算法数据结构
    1.力扣977：有序数组的平方1.1题目：给你一个按非递减顺序排序的整数数组nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。示例1：输入：nums=[-4,-1,0,3,10]输出：[0,1,9,16,100]解释：平方后，数组变为[16,1,0,9,100]排序后，数组变为[0,1,9,16,100]示例2：输入：nums=[-7,-3,2,3,11]输出：[4,9,9,49,
  • 数据结构与算法 python实现单链表实现对列 我只要一发 python数据结构与算法Python实现单链表实现对列
    对列：先来的先走，后来的后走FIFO实现FIFO的实现数据结构：arroylistlinkedlistdoubllinkedlist最基本的操作，push入列pop出列单链表实现appendpopleftclassFullError(Exception):passclassEmptyError(Exception):passclassQueue(object):def__init__(self,m
  • 周四 2020-01-09 08:00 - 24:30 多云 02h10m 么得感情的日更机器
    南昌。二〇二〇年一月九日基本科研[1]:1.论文阅读论文--二小时十分2.论文实现实验--小时3.数学SINS推导回顾--O分4.科研参考书【】1)的《》看0/0页-5.科研文档1)组织工作[1]:例会--英语能力[2]:1.听力--十分2.单词--五分3.口语--五分4.英语文档1)编程能力[2]:1.编程语言C语言--O分2.数据结构与算法C语言数据结构--O分3.编程参考书1)陈正冲的《C语
  • github源码指引：共享内存、数据结构与算法：树形结构ListTree 初级代码游戏 github源码指引共享内存数据结构与算法github共享内存树链表
    初级代码游戏的专栏介绍与文章目录-CSDN博客我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。专题：共享内存、数据结构与算法_初级代码游戏的博客-CSDN博客本文讲解带有子项的链表。一、介绍与上一篇介绍的单向链表相比，多了一个子项指针。可以理解为原来的链表是兄弟关系，
  • 代码随想录+力扣刷题记录+华为机考准备记录 梁慢慢慢慢 leetcode算法数据结构
    为了准备华为机考的刷题记录，已压线过背景：数据结构与算法零基础，此前没有刷过题，会Python。学习路线按照代码随想录的顺序刷题，刷题平台：力扣以上大致过了一遍后开始刷华为机考真题（cdsn上购买的真题，刷题平台是购买的真题中的OJ平台，也是ACM模式）总共用时1个月。完成情况：力扣80个题+华为2024年机考真题。大部分题目都只做过1次，掌握得很不牢固，机考的时候也是压线过。时间比较紧急，做到后
  • “八股文”在程序员面试中的价值：助力还是阻力？ 精神阿祝 尝鲜面试职场和发展
    文章目录引言1.什么是“八股文”？2.“八股文”的支持者观点2.1理论基础的重要性2.2规范与标准化2.3应对突发问题3.“八股文”的反对者观点3.1实战经验的重视3.2忽视创新与灵活性3.3学习成本与心理压力4.八股文的具体内容分析4.1数据结构与算法4.1.1数据结构的重要性4.1.2算法的应用4.2系统设计4.2.1系统的架构设计4.2.2高并发处理4.3编程语言基础4.4框架与工具的使用5
  • 邓俊辉数据结构与算法学习笔记-第五章 xiaodidadada 数据结构与算法
    文章目录树aa1树a2应用a3有根树a4有序树a5路径a6连通图无环图a7深度层次b在计算机中表示b1树的表示b2父节点b3孩子节点b4父亲孩子表示法b5长子兄弟表示法c二叉树c1二叉树概述c2真二叉树c3描述多叉树d二叉树d1BinNode类d2BinNode接口d3BinTree类d4高度更新d5节点插入e相关算法e1-1先序遍历转化策略e1-2遍历规则e1-3递归实现e1-4迭代实现e1-5
  • 【数据结构与算法 | 每日一题力扣篇】 Vez'nan的幸福生活 leetcode算法职场和发展
    1.力扣3174：清楚数字1.1题目：给你一个字符串s。你的任务是重复以下操作删除所有数字字符：删除第一个数字字符以及它左边最近的非数字字符。请你返回删除所有数字字符以后剩下的字符串。示例1：输入：s="abc"输出："abc"解释：字符串中没有数字。示例2：输入：s="cb34"输出：""解释：一开始，我们对s[2]执行操作，s变为"c4"。然后对s[1]执行操作，s变为""。提示：1deque
  • 【数据结构与算法 | 基础篇】模拟LinkedList实现的链表(无哨兵) Vez'nan的幸福生活 java数据结构算法
    1.前言我们将LinkdList视作链表,底层设计了内部类Node类,我这里依然没有用到泛型,其实加上泛型依然很简单,即将Node节点的数据域的类型由Int转换为E(),我在此不做赘述.同时实现了增删查改,遍历等操作.2.链表(无哨兵)的代码实现publicclassLinkListTestimplementsIterable{//头指针staticNodehead;//内部类privatesta
  • 数据结构与算法Day25----字符串匹配（一）：借助哈希算法实现 墨殇染泪
    一、主串和模式串：  假设在字符串A中查找字符串B，那字符串A就是主串，字符串B就是模式串。把主串的长度记作，模式串的长度记作。因为是在主串中查找模式串，所以。二、暴力匹配算法/朴素匹配算法/BF(BruteForce)算法：1、算法思想：  在主串中，检查起始位置分别是0、1、2···且长度为的个子串，看有没有跟模式串匹配的。2、图示：3、时间复杂度：  在极端情况下，每次都比对个字符，要比对次
  • Java学习 - 数据结构与算法 - 有序数组去重详解 泡芙萝莉酱 Javajava学习开发语言算法数据结构
    问题给定一个有序数组，要删除数组重复出现的元素，使得每个元素只出现一次，然后返回移除重复数组后的新长度；示例：假设给定一个数组nums=[1,2,4,4]，删除重复出现的元素4后，原数组变成nums=[1,2,4]，此时新的数组长度为3；解决思路数组原地操作数组原地操作，此时无需创建新的数组，只需要在原来的数组上操作即可。相当于首先要找到数组中重复的元素，然后将重复的元素移除，此时就涉及到数组中的
  • 4. 数据结构与算法：双端队列- sszhang
    双端队列（deque，全名double-endedqueue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队首（front）、队尾（rear），但与队列不同的是，插入操作在两端（队首和队尾）都可以进行，删除操作也一样。deque()创建双端队列addFront(item)向队首插入项addRear(item)向队尾插入项removeFront()返回队首的项，并从双端队列中删除该项r
  • github源码指引：共享内存、数据结构与算法：字符串池StringPool 初级代码游戏 github源码指引共享内存数据结构与算法github共享内存字符串池
    初级代码游戏的专栏介绍与文章目录-CSDN博客我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。专题：共享内存、数据结构与算法_初级代码游戏的博客-CSDN博客本文讲解字符串池的示例代码。字符串池是一个特殊的结构，用来减少重复的字符串存储（现实系统中会存在大量重复的字符
  • 数据结构与算法之哈希表（C语言版） jiangzhangha 算法与数据结构学习笔记算法哈希表
    title:数据结构与算法之哈希表（C语言版）date:2020-07-1921:05:15categories:数据结构与算法tags:-数据结构-算法-哈希表-c数据结构与算法之哈希表（C语言版）哈希表支持一种最有效的检索方法：散列。由于计算哈希值和在数组中进行索引都只消耗固定的时间，因此哈希表最大的亮点在于其是一种运行时间在常量级别的检索方法。绝大多数的哈希函数会将一些不同的键映射到表中相同
  • 数据结构与算法关系(中)：如何评判一个算法的好坏 MobotStone
    大家好，我是MicroStone，一个曾在三家世界500强企业担任要职的一线互联网工程师。上一节，我们了解到算法的一些特征，想必大家都掌握了算法设计要求，在学习或工作中根据业务需求设计要设计一个算法，我们要如何评估一个算法的好坏呐？下面我们来看看算法的度量方式。1、算法的效率度量方法我们知道一个算法的效率，抛开性能这些，其实值得注意的就是算法的执行时间，同一台机器上，我们使用相同数据集，利用计算机
  • 聊聊自学数据结构与算法 莫天幽 数据结构算法
    聊聊自学数据结构与算法大家好，我是莫幽天很高兴你能够阅读到我的文章。说道自学算法，不知道你是带着一个什么样的心情来学习，我呢是觉得基础太重要了。所以又来尝试深入的学习数据结构与算法。为什么这么说呢，我是一名Java开发的程序猿，现在jdk已经出到18了（时间北京时间：2021-07-28），但是呢开发一般还在用jdk8。一般的Java程序猿也就了解个jdk8的特性。上层变化的太快，想记忆需要长期持
  • github源码指引：共享内存、数据结构与算法：平衡二叉树set带有互斥接口的 初级代码游戏 github源码指引共享内存数据结构与算法github哈希算法算法共享内存
    初级代码游戏的专栏介绍与文章目录-CSDN博客我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。目录一、演示代码二、互斥层的实现2.1简单的互斥层实现2.2完整互斥接口的实现2.2.1互斥对象放在哪里2.2.2迭代器的互斥2.2.3方法的互斥三、互斥层的设计思想一、演示
  • github源码指引：共享内存、数据结构与算法：平衡二叉树set的lower_bound 初级代码游戏 github源码指引共享内存数据结构与算法github哈希算法算法
    初级代码游戏的专栏介绍与文章目录-CSDN博客我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。本篇专门讲解lower_bound的实现。目录一、STL的lower_bound和upper_bound是什么二、二叉树有没有lower_bound三、演示代码3.1定义数据
  • 编程练习题目集【目录】 绯樱殇雪 目录PTAc++javapat考试
    所有负面情绪都源于你的弱小，唯有强大自己才能够百毒不侵。文章目录一、PTA1.练习（1）中国大学MOOC-陈越、何钦铭-数据结构-起步能力自测题（2）DataStructuresandAlgorithms(English)（3）数据结构与算法题目集（中文）（4）团体程序设计天梯赛-练习集（5）基础编程题目集①函数题②编程题2.考试（1）PAT(BasicLevel)Practice（中文）（2）P
  • github源码指引：共享内存、数据结构与算法：作为基础的数组 初级代码游戏 github源码指引共享内存数据结构与算法github共享内存数据结构算法可扩展数组
    初级代码游戏的专栏介绍与文章目录-CSDN博客我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。相关专题：共享内存、数据结构与算法_初级代码游戏的博客-CSDN博客源码位置：shmfc基础：github源码指引：源码结构、编译、运行_github编译-CSDN博客目录一
  • 驾驭高效编程:一探C++ STL的奥秘 一叶之秋1412 c++开发语言
    1.什么是STL2.:STL的版本2.1:原始版本2.2:P.J版本2.3:RW版本2.4:SGI版本3:STL的六大组件4:如何学习STL5:STL的缺陷1.什么是STLSTL(standdardtemplatelibrary-标准模板库):是C++标准库的重要组成部分,不仅是一个可复用的组件库,而且是一个包含数据结构与算法软件框架.2.:STL的版本2.1:原始版本AlexanderStepa
  • 【数据结构与算法】从左到右快速幂和从右到左快速幂 星眺北海 数据结构与算法算法快速幂
    引出问题在计算机科学中，幂运算是一种非常常见且基础的操作，尤其是在涉及到大数运算时，幂运算的效率对整个计算过程至关重要。设想以下场景：在加密算法中，如RSA算法，常常需要计算大数的幂，且这种计算必须在一定时间内完成，以确保安全性。在数值计算中，我们可能需要反复进行大规模的幂运算，如果采用最直接的计算方法，其计算量和时间将非常庞大。如果我们采用朴素的计算方法，例如计算aba^bab时，通过不断相乘a
  • 我的程序员读书路 weixin_30416497 c#javascript大数据ViewUI
    CLRviaC#(第三版)你必须知道的.NET(第二版)编码:隐匿在计算机软硬件背后的语言代码整洁之道重构:改善既有代码的设计数据结构与算法：C#语言描述程序员修炼之道:从小工到专家编程珠玑(第2版)深入理解计算机系统(第2版)数据挖掘概念与技术(第2版)高效程序员的45个习惯:敏捷开发修炼之道面向对象分析与设计(第三版)深入浅出设计模式(c#/java版)代码大全第二版设计模式:可复用面向对象软
  • JAVA基础 灵静志远 位运算加载Date字符串池覆盖
    一、类的初始化顺序 1 （静态变量，静态代码块）-->（变量，初始化块）--> 构造器 同一括号里的，根据它们在程序中的顺序来决定。上面所述是同一类中。如果是继承的情况，那就在父类到子类交替初始化。 二、String 1 String a = "abc"; JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的对象，根
  • keepalived实现redis主从高可用 bylijinnan redis
    方案说明 两台机器（称为A和B），以统一的VIP对外提供服务 1.正常情况下，A和B都启动，B会把A的数据同步过来（B is slave of A） 2.当A挂了后，VIP漂移到B；B的keepalived 通知redis 执行：slaveof no one，由B提供服务 3.当A起来后，VIP不切换，仍在B上面；而A的keepalived 通知redis 执行slaveof B，开始
  • java文件操作大全 0624chenhong java
    最近在博客园看到一篇比较全面的文件操作文章，转过来留着。 http://www.cnblogs.com/zhuocheng/archive/2011/12/12/2285290.html 转自http://blog.sina.com.cn/s/blog_4a9f789a0100ik3p.html 一.获得控制台用户输入的信息    &nbs
  • android学习任务 不懂事的小屁孩 工作
    任务 完成情况 搞清楚带箭头的pupupwindows和不带的使用 已完成 熟练使用pupupwindows和alertdialog，并搞清楚两者的区别 已完成 熟练使用android的线程handler,并敲示例代码 进行中 了解游戏2048的流程，并完成其代码工作 进行中-差几个actionbar 研究一下android的动画效果，写一个实例 已完成 复习fragem
  • zoom.js 换个号韩国红果果 oom
    它的基于bootstrap 的 https://raw.github.com/twbs/bootstrap/master/js/transition.js  transition.js模块引用顺序 <link rel="stylesheet" href="style/zoom.css"> <script src=&q
  • 详解Oracle云操作系统Solaris 11.2 蓝儿唯美 Solaris
    当Oracle发布Solaris 11时，它将自己的操作系统称为第一个面向云的操作系统。Oracle在发布Solaris 11.2时继续它以云为中心的基调。但是，这些说法没有告诉我们为什么Solaris是配得上云的。幸好，我们不需要等太久。Solaris11.2有4个重要的技术可以在一个有效的云实现中发挥重要作用：OpenStack、内核域、统一存档（UA）和弹性虚拟交换（EVS）。 
  • spring学习——springmvc（一） a-john springMVC
    Spring MVC基于模型-视图-控制器（Model-View-Controller，MVC）实现，能够帮助我们构建像Spring框架那样灵活和松耦合的Web应用程序。   1，跟踪Spring MVC的请求 请求的第一站是Spring的DispatcherServlet。与大多数基于Java的Web框架一样，Spring MVC所有的请求都会通过一个前端控制器Servlet。前
  • hdu4342 History repeat itself-------多校联合五 aijuans 数论
    水题就不多说什么了。 #include<iostream>#include<cstdlib>#include<stdio.h>#define ll __int64using namespace std;int main(){ int t; ll n; scanf("%d",&t); while(t--)
  • EJB和javabean的区别 asia007 beanejb
    EJB不是一般的JavaBean,EJB是企业级JavaBean,EJB一共分为3种,实体Bean,消息Bean,会话Bean,书写EJB是需要遵循一定的规范的,具体规范你可以参考相关的资料.另外,要运行EJB,你需要相应的EJB容器,比如Weblogic,Jboss等,而JavaBean不需要,只需要安装Tomcat就可以了   1.EJB用于服务端应用开发, 而JavaBeans
  • Struts的action和Result总结 百合不是茶 strutsAction配置Result配置
        一:Action的配置详解:      下面是一个Struts中一个空的Struts.xml的配置文件     <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC &quo
  • 如何带好自已的团队 bijian1013 项目管理团队管理团队
    在网上看到博客" 怎么才能让团队成员好好干活"的评论，觉得写的比较好。 原文如下： 我做团队管理有几年了吧，我和你分享一下我认为带好团队的几点： 1.诚信         对团队内成员，无论是技术研究、交流、问题探讨，要尽可能的保持一种诚信的态度，用心去做好，你的团队会感觉得到。 2.努力提
  • Java代码混淆工具 sunjing ProGuard
    Open Source Obfuscators ProGuard http://java-source.net/open-source/obfuscators/proguardProGuard is a free Java class file shrinker and obfuscator. It can detect and remove unused classes, fields, m
  • 【Redis三】基于Redis sentinel的自动failover主从复制 bit1129 redis
    在第二篇中使用2.8.17搭建了主从复制，但是它存在Master单点问题，为了解决这个问题，Redis从2.6开始引入sentinel，用于监控和管理Redis的主从复制环境，进行自动failover，即Master挂了后，sentinel自动从从服务器选出一个Master使主从复制集群仍然可以工作，如果Master醒来再次加入集群，只能以从服务器的形式工作。   什么是Sentine
  • 使用代理实现Hibernate Dao层自动事务 白糖_ DAOspringAOP框架Hibernate
    都说spring利用AOP实现自动事务处理机制非常好，但在只有hibernate这个框架情况下，我们开启session、管理事务就往往很麻烦。 public void save(Object obj){ Session session = this.getSession(); Transaction tran = session.beginTransaction(); try
  • maven3实战读书笔记 braveCS maven3
    Maven简介 是什么？ Is a software project management and comprehension tool.项目管理工具 是基于POM概念(工程对象模型) [设计重复、编码重复、文档重复、构建重复，maven最大化消除了构建的重复] [与XP：简单、交流与反馈；测试驱动开发、十分钟构建、持续集成、富有信息的工作区]     功能：
  • 编程之美-子数组的最大乘积 bylijinnan 编程之美
    public class MaxProduct { /** * 编程之美 子数组的最大乘积 * 题目: 给定一个长度为N的整数数组，只允许使用乘法，不能用除法，计算任意N-1个数的组合中乘积中最大的一组，并写出算法的时间复杂度。 * 以下程序对应书上两种方法，求得“乘积中最大的一组”的乘积——都是有溢出的可能的。 * 但按题目的意思，是要求得这个子数组，而不
  • 读书笔记-2 chengxuyuancsdn 读书笔记
    1、反射 2、oracle年-月-日 时-分-秒 3、oracle创建有参、无参函数 4、oracle行转列 5、Struts2拦截器 6、Filter过滤器(web.xml) 1、反射 (1)检查类的结构 在java.lang.reflect包里有3个类Field,Method,Constructor分别用于描述类的域、方法和构造器。 2、oracle年月日时分秒 s
  • [求学与房地产]慎重选择IT培训学校 comsci it
          关于培训学校的教学和教师的问题,我们就不讨论了,我主要关心的是这个问题       培训学校的教学楼和宿舍的环境和稳定性问题       我们大家都知道，房子是一个比较昂贵的东西，特别是那种能够当教室的房子... &nb
  • RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 daizj oraclermanfilespersetPARALLELISM
    RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 转 PARALLELISM --- 我们还可以通过parallelism参数来指定同时"自动"创建多少个通道： RMAN > configure device type disk parallelism 3 ; 表示启动三个通道，可以加快备份恢复的速度。
  • 简单排序:冒泡排序 dieslrae 冒泡排序
    public void bubbleSort(int[] array){ for(int i=1;i<array.length;i++){ for(int k=0;k<array.length-i;k++){ if(array[k] > array[k+1]){
  • 初二上学期难记单词三 dcj3sjt126com sciet
    concert 音乐会 tonight 今晚 famous 有名的；著名的 song 歌曲 thousand 千 accident 事故；灾难 careless 粗心的，大意的 break 折断；断裂；破碎 heart 心（脏） happen  偶尔发生，碰巧 tourist 旅游者；观光者 science （自然）科学 marry 结婚 subject 题目；
  • I.安装Memcahce 1. 安装依赖包libevent Memcache需要安装libevent,所以安装前可能需要执行 Shell代码 收藏代码 dcj3sjt126com redis
    wget http://download.redis.io/redis-stable.tar.gz tar xvzf redis-stable.tar.gz cd redis-stable make   前面3步应该没有问题，主要的问题是执行make的时候，出现了异常。 异常一： make[2]: cc: Command not found 异常原因：没有安装g
  • 并发容器 shuizhaosi888 并发容器
       通过并发容器来改善同步容器的性能，同步容器将所有对容器状态的访问都串行化，来实现线程安全，这种方式严重降低并发性，当多个线程访问时，吞吐量严重降低。    并发容器ConcurrentHashMap       替代同步基于散列的Map，通过Lock控制。   &nb
  • Spring Security（12）——Remember-Me功能 234390216 Spring SecurityRemember Me记住我
    Remember-Me功能   目录   1.1     概述 1.2     基于简单加密token的方法 1.3     基于持久化token的方法 1.4     Remember-Me相关接口和实现
  • 位运算 焦志广 位运算
    一、位运算符Ｃ语言提供了六种位运算符： & 按位与 | 按位或 ^ 按位异或 ~ 取反 << 左移 >> 右移 1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。 例如：9&am
  • nodejs 数据库连接 mongodb mysql liguangsong mongodbmysqlnode数据库连接
    1.mysql 连接    package.json中dependencies加入     "mysql":"~2.7.0"    执行 npm install      在config 下创建文件 database.js    
  • java动态编译 olive6615 javaHotSpotjvm动态编译
        在HotSpot虚拟机中，有两个技术是至关重要的，即动态编译(Dynamic compilation)和Profiling。     HotSpot是如何动态编译Javad的bytecode呢？Java bytecode是以解释方式被load到虚拟机的。HotSpot里有一个运行监视器，即Profile Monitor,专门监视
  • Storm0.9.5的集群部署配置优化 roadrunners 优化storm.yaml
    nimbus结点配置（storm.yaml）信息： # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional inf
  • 101个MySQL 的调节和优化的提示 tomcat_oracle mysql
    　1. 拥有足够的物理内存来把整个InnoDB文件加载到内存中——在内存中访问文件时的速度要比在硬盘中访问时快的多。 　　2. 不惜一切代价避免使用Swap交换分区 – 交换时是从硬盘读取的，它的速度很慢。 　　3. 使用电池供电的RAM（注：RAM即随机存储器）。 　　4. 使用高级的RAID（注：Redundant Arrays of Inexpensive Disks，即磁盘阵列
  • zoj 3829 Known Notation(贪心) 阿尔萨斯 ZOJ
    题目链接：zoj 3829 Known Notation 题目大意：给定一个不完整的后缀表达式，要求有2种不同操作，用尽量少的操作使得表达式完整。 解题思路：贪心，数字的个数要要保证比∗的个数多1，不够的话优先补在开头是最优的。然后遍历一遍字符串，碰到数字+1，碰到∗-1,保证数字的个数大于等1，如果不够减的话，可以和最后面的一个数字交换位置（用栈维护十分方便），因为添加和交换代价都是1
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他