叶子心情你不懂
叶子心情你不懂

Kuangbin专题四最短路练习

刷了两天半终于百度完了所有题。什么时候能自己写出题目。Orz，太菜了。

 

A - Til the Cows Come Home

 POJ - 2387 

Bessie is out in the field and wants to get back to the barn to get as much sleep as possible before Farmer John wakes her for the morning milking. Bessie needs her beauty sleep, so she wants to get back as quickly as possible. 

Farmer John's field has N (2 <= N <= 1000) landmarks in it, uniquely numbered 1..N. Landmark 1 is the barn; the apple tree grove in which Bessie stands all day is landmark N. Cows travel in the field using T (1 <= T <= 2000) bidirectional cow-trails of various lengths between the landmarks. Bessie is not confident of her navigation ability, so she always stays on a trail from its start to its end once she starts it. 

Given the trails between the landmarks, determine the minimum distance Bessie must walk to get back to the barn. It is guaranteed that some such route exists.

Input

* Line 1: Two integers: T and N 

* Lines 2..T+1: Each line describes a trail as three space-separated integers. The first two integers are the landmarks between which the trail travels. The third integer is the length of the trail, range 1..100.

Output

* Line 1: A single integer, the minimum distance that Bessie must travel to get from landmark N to landmark 1.

Sample Input

5 5
1 2 20
2 3 30
3 4 20
4 5 20
1 5 100

Sample Output

90

Hint

INPUT DETAILS: 

There are five landmarks. 

OUTPUT DETAILS: 

Bessie can get home by following trails 4, 3, 2, and 1.

板子题，我dijkstra板子用了堆优化，所以没有判断重边。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 11000
#define M 3645
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int t, n;
struct edge{
  int v, w;
};
vector G[N];
int d[N];

void dijkstra()
{
    priority_queue< P, vector
, greater
 > que;
    memset(d, INF, sizeof d);
    d[n] = 0;
    que.push(P(0, n));

    while(!que.empty()) {
        P h = que.top(); que.pop();

        int v = h.se;
        if(d[v] < h.fi) continue;

        for(int i = 0; i < G[v].size(); i++) {
            edge e = G[v][i];
            if(d[e.v] > d[v] + e.w)
                d[e.v] = d[v] + e.w, que.push(P(d[e.v], e.v));
        }
    }
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    scanf("%d%d", &t, &n);

    int u, v, w;
    edge e;
    rep(i, 1, t) {
        scanf("%d%d%d", &u, &v, &w);
        e.v = v; e.w = w;
        G[u].push_back(e);
        e.v = u;
        G[v].push_back(e);
    }

    dijkstra();

    printf("%d\n", d[1]);

    return 0;
}

B - Frogger

 POJ - 2253 

Freddy Frog is sitting on a stone in the middle of a lake. Suddenly he notices Fiona Frog who is sitting on another stone. He plans to visit her, but since the water is dirty and full of tourists' sunscreen, he wants to avoid swimming and instead reach her by jumping. 
Unfortunately Fiona's stone is out of his jump range. Therefore Freddy considers to use other stones as intermediate stops and reach her by a sequence of several small jumps. 
To execute a given sequence of jumps, a frog's jump range obviously must be at least as long as the longest jump occuring in the sequence. 
The frog distance (humans also call it minimax distance) between two stones therefore is defined as the minimum necessary jump range over all possible paths between the two stones. 

You are given the coordinates of Freddy's stone, Fiona's stone and all other stones in the lake. Your job is to compute the frog distance between Freddy's and Fiona's stone. 

Input

The input will contain one or more test cases. The first line of each test case will contain the number of stones n (2<=n<=200). The next n lines each contain two integers xi,yi (0 <= xi,yi <= 1000) representing the coordinates of stone #i. Stone #1 is Freddy's stone, stone #2 is Fiona's stone, the other n-2 stones are unoccupied. There's a blank line following each test case. Input is terminated by a value of zero (0) for n.

Output

For each test case, print a line saying "Scenario #x" and a line saying "Frog Distance = y" where x is replaced by the test case number (they are numbered from 1) and y is replaced by the appropriate real number, printed to three decimals. Put a blank line after each test case, even after the last one.

Sample Input

2
0 0
3 4

3
17 4
19 4
18 5

0

Sample Output

Scenario #1
Frog Distance = 5.000

Scenario #2
Frog Distance = 1.414

要求所有路中的最短的最长边是多少。

这题和最短路扯上关系有点难想。d[u]表示从1到u的路中最长边，那么就能松弛：d[v] = min(d[v], max(d[u], g[u][v]))；

dijkstra求最短路是每次从已经确定d的集合中选出d值最小的来松弛，路的权值是所有边的权值和，求的是权值最小的路；这里也是从已经确定d的集合中选出d值最小的来松弛，路的权值是这条路中最长的边，求的也是权值最小的路。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 210
#define M 3645
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int t, n;
double dis[N][N];
P ps[N];
double d[N];

void dijkstra()
{
    fill(d, d + N, INF);
    d[1] = 0;

    priority_queue, greater
 > que;
    que.push(P(0.0, 1));

    while(!que.empty()) {
        P h = que.top(); que.pop();
        int v = h.se;
        //if(d[v] < h.fi) continue;

        for(int i = 1; i <= n; i++) {
            double tmp = max(d[v], dis[v][i]);
            if(d[i] > tmp) {
                d[i] = tmp;
                que.push(P(d[i], i));
            }
        }
    }
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    while(~scanf("%d", &n) && n) {
        rep(i, 1, n) scanf("%lf%d", &ps[i].fi, &ps[i].se);
        rep(i, 1, n) rep(j, 1, n) {
            double dx = ps[i].fi - ps[j].fi;
            double dy = ps[i].se - ps[j].se;
            dis[i][j] = dx * dx + dy * dy;
            dis[i][j] = sqrt(dis[i][j]);
        }
        dijkstra();
        if(t) puts("");
        printf("Scenario #%d\nFrog Distance = %.3f\n", ++t, d[2]);
    }

    return 0;
}

C - Heavy Transportation

 POJ - 1797

Background 
Hugo Heavy is happy. After the breakdown of the Cargolifter project he can now expand business. But he needs a clever man who tells him whether there really is a way from the place his customer has build his giant steel crane to the place where it is needed on which all streets can carry the weight. 
Fortunately he already has a plan of the city with all streets and bridges and all the allowed weights.Unfortunately he has no idea how to find the the maximum weight capacity in order to tell his customer how heavy the crane may become. But you surely know. 

Problem 
You are given the plan of the city, described by the streets (with weight limits) between the crossings, which are numbered from 1 to n. Your task is to find the maximum weight that can be transported from crossing 1 (Hugo's place) to crossing n (the customer's place). You may assume that there is at least one path. All streets can be travelled in both directions.

Input

The first line contains the number of scenarios (city plans). For each city the number n of street crossings (1 <= n <= 1000) and number m of streets are given on the first line. The following m lines contain triples of integers specifying start and end crossing of the street and the maximum allowed weight, which is positive and not larger than 1000000. There will be at most one street between each pair of crossings.

Output

The output for every scenario begins with a line containing "Scenario #i:", where i is the number of the scenario starting at 1. Then print a single line containing the maximum allowed weight that Hugo can transport to the customer. Terminate the output for the scenario with a blank line.

Sample Input

1
3 3
1 2 3
1 3 4
2 3 5

Sample Output

Scenario #1:
4

和上一题一样，只不过反过来了。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 1010
#define M 3645
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int t, n, m, u, v, w;
int dis[N][N];
bool vis[N];
int d[N];

void dijkstra()
{
    memset(vis, false, sizeof vis);
    memset(d, 0, sizeof d);
    rep(i, 1, n) d[i] = dis[1][i];
    vis[1] = true;

    rep(i, 1, n) {
        int maxn = 0, p;
        rep(j, 1, n)  {
            if(!vis[j] && d[j] > maxn) {
                maxn = d[j];
                p = j;
            }
        }

        vis[p] = true;
        rep(k, 1, n) {
            d[k] = max(d[k], min(d[p], dis[p][k]));
        }
    }
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    scanf("%d", &t);

    rep(Case, 1, t) {
        scanf("%d%d", &n, &m);
        rep(i, 1, n) rep(j, 1, n) dis[i][j] = 0;
        rep(i, 1, m) {
            scanf("%d%d%d", &u, &v, &w);
            dis[u][v] = max(dis[u][v], w);
            dis[v][u] = max(dis[v][u], w);
        }

        dijkstra();

        printf("Scenario #%d:\n%d\n\n", Case, d[n]);
    }

    return 0;
}

D - Silver Cow Party

 POJ - 3268

One cow from each of N farms (1 ≤ N ≤ 1000) conveniently numbered 1..N is going to attend the big cow party to be held at farm #X (1 ≤ X ≤ N). A total of M (1 ≤ M≤ 100,000) unidirectional (one-way roads connects pairs of farms; road i requires Ti (1 ≤ Ti ≤ 100) units of time to traverse.

Each cow must walk to the party and, when the party is over, return to her farm. Each cow is lazy and thus picks an optimal route with the shortest time. A cow's return route might be different from her original route to the party since roads are one-way.

Of all the cows, what is the longest amount of time a cow must spend walking to the party and back?

Input

Line 1: Three space-separated integers, respectively: N, M, and X 
Lines 2.. M+1: Line i+1 describes road i with three space-separated integers: Ai,Bi, and Ti. The described road runs from farm Ai to farm Bi, requiring Ti time units to traverse.

Output

Line 1: One integer: the maximum of time any one cow must walk.

Sample Input

4 8 2
1 2 4
1 3 2
1 4 7
2 1 1
2 3 5
3 1 2
3 4 4
4 2 3

Sample Output

10

Hint

Cow 4 proceeds directly to the party (3 units) and returns via farms 1 and 3 (7 units), for a total of 10 time units.

这题我看数据量直接对每个点跑了个nlogn的dijkstra，复杂度是n^2longn，没超时哈哈哈哈。。。其实现在写博客觉得可以反过来建图，就是原来(u, v, w)变成(v, u, w)。然后跑两遍就行了。

注释的是n^2logn的代码过了哈哈哈哈哈哈哈。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 1010
#define M 100010
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int n, m, x, a[M], b[M], c[M], ans;
int d[N], d1[N], d2[N];
struct Edge {
  int v, w;
}e;
vector G[N];
priority_queue, greater
 > que;

void dijkstra()
{
    memset(d, INF, sizeof d);
    while(!que.empty()) que.pop();
    que.push(P(0, x));
    d[x] = 0;

    while(!que.empty()) {
        P h = que.top(); que.pop();

        if(d[h.se] < h.fi) continue;

        for(int i = 0; i < G[h.se].size(); i++) {
            Edge & e = G[h.se][i];
            if(d[e.v] > d[h.se] + e.w) {
                d[e.v] = d[h.se] + e.w;
                que.push(P(d[e.v], e.v));
            }
        }
    }
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    while(~scanf("%d%d%d", &n, &m, &x)) {
        rep(i, 1, n) G[i].clear();
        rep(i, 1, m) {
            scanf("%d%d%d", &a[i], &b[i], &c[i]);
            e.v = b[i]; e.w = c[i];
            G[a[i]].push_back(e);
        }
        dijkstra();
        memcpy(d1, d, sizeof d);

        rep(i, 1, n) G[i].clear();
        rep(i, 1, m) {
            e.v = a[i]; e.w = c[i];
            G[b[i]].push_back(e);
        }
        dijkstra();
        memcpy(d2, d, sizeof d);

        ans = 0;
        rep(i, 1, n) ans = max(ans, d1[i] + d2[i]);

        printf("%d\n", ans);
    }

    return 0;
}

//#include 
//#include 
//#include 
//#include 
//#include 
//#include 
//#include 
//#include 
//#include 
//#include 
//using namespace std;
//typedef pair P;
//typedef long long ll;
//#define N 1010
//#define M 3645
//const int INF = 0x3f3f3f3f;
//const double eps = 1e-5;
//const double PI = acos(-1);
//#define fi first
//#define se second
//#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)
//
//int n, m, x, a, b, c, ans;
//int d[N][N];
//struct Edge {
//  int v, w;
//}e;
//vector G[N];
//priority_queue, greater
 > que;
//
//void dijkstra(int s)
//{
//    memset(d[s], INF, sizeof d[s]);
//    while(!que.empty()) que.pop();
//    que.push(P(0, s));
//    d[s][s] = 0;
//
//    while(!que.empty()) {
//        P h = que.top(); que.pop();
//
//        if(d[s][h.se] < h.fi) continue;
//
//        for(int i = 0; i < G[h.se].size(); i++) {
//            Edge & e = G[h.se][i];
//            if(d[s][e.v] > d[s][h.se] + e.w) {
//                d[s][e.v] = d[s][h.se] + e.w;
//                que.push(P(d[s][e.v], e.v));
//            }
//        }
//    }
//}
//
//int main()
//{
//    #ifndef ONLINE_JUDGE
//    freopen("data.txt", "r", stdin);
//    #endif
//
//    while(~scanf("%d%d%d", &n, &m, &x)) {
//        rep(i, 1, n) G[i].clear();
//        rep(i, 1, m) {
//            scanf("%d%d%d", &a, &b, &c);
//            e.v = b; e.w = c;
//            G[a].push_back(e);
//        }
//
//        rep(i, 1, n) dijkstra(i);
//
//        ans = 0;
//        rep(i, 1, n) ans = max(ans, d[i][x] + d[x][i]);
//
//        printf("%d\n", ans);
//    }
//
//    return 0;
//}

E - Currency Exchange

 POJ - 1860

Several currency exchange points are working in our city. Let us suppose that each point specializes in two particular currencies and performs exchange operations only with these currencies. There can be several points specializing in the same pair of currencies. Each point has its own exchange rates, exchange rate of A to B is the quantity of B you get for 1A. Also each exchange point has some commission, the sum you have to pay for your exchange operation. Commission is always collected in source currency. 
For example, if you want to exchange 100 US Dollars into Russian Rubles at the exchange point, where the exchange rate is 29.75, and the commission is 0.39 you will get (100 - 0.39) * 29.75 = 2963.3975RUR. 
You surely know that there are N different currencies you can deal with in our city. Let us assign unique integer number from 1 to N to each currency. Then each exchange point can be described with 6 numbers: integer A and B - numbers of currencies it exchanges, and real R AB, C AB, R BA and C BA - exchange rates and commissions when exchanging A to B and B to A respectively. 
Nick has some money in currency S and wonders if he can somehow, after some exchange operations, increase his capital. Of course, he wants to have his money in currency S in the end. Help him to answer this difficult question. Nick must always have non-negative sum of money while making his operations. 

Input

The first line of the input contains four numbers: N - the number of currencies, M - the number of exchange points, S - the number of currency Nick has and V - the quantity of currency units he has. The following M lines contain 6 numbers each - the description of the corresponding exchange point - in specified above order. Numbers are separated by one or more spaces. 1<=S<=N<=100, 1<=M<=100, V is real number, 0<=V<=10 3. 
For each point exchange rates and commissions are real, given with at most two digits after the decimal point, 10 -2<=rate<=10 2, 0<=commission<=10 2. 
Let us call some sequence of the exchange operations simple if no exchange point is used more than once in this sequence. You may assume that ratio of the numeric values of the sums at the end and at the beginning of any simple sequence of the exchange operations will be less than 10 4. 

Output

If Nick can increase his wealth, output YES, in other case output NO to the output file.

Sample Input

3 2 1 20.0
1 2 1.00 1.00 1.00 1.00
2 3 1.10 1.00 1.10 1.00

Sample Output

YES

只有判断负环的板子，，，，没想到还能判断正环，差不多，都是松弛。

用Bellman和Floyed各写了一个，Spfa也能写。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 110
#define M 3645
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int n, m, s;
double v;
int a, b;
double r1, c1, r2, c2;
struct Cost{
  double r, c;
  Cost (double r = 0.0, double c = 0.0):r(r), c(c){}
}cost[N][N];
vector G[N];
double d[N];
bool vis[N];

double go(double sum, int x, int y){
    return (sum - cost[x][y].c) * cost[x][y].r;
}

//bool solve()
//{
//    fill(d, d + N, 0);
//    d[s] = v;
//
//    rep(k, 1, n) {
//        bool flag = false;
//        rep(i, 1, n)
//        for(int j = 0; j < G[i].size(); j++) {
//            int v = G[i][j];
//            if(d[v] < go(d[i], i, v)) {
//                d[v] = go(d[i], i, v);
//                flag = true;
//            }
//        }
//        if(!flag) return false;
//        if(k == n) return true;
//    }
//
//    return false;
//}

bool solve()
{
    fill(d, d + N, 0);
    d[s] = v;

    rep(k, 1, n) rep(i, 1, n) rep(j, 1, n) {
        d[j] = max(d[j], go(d[i], i, j));
    }

    rep(i, 1, n) for(int j = 0; j < G[i].size(); j++) {
        int v = G[i][j];
        if(d[v] < go(d[i], i, v))
            return true;
    }

    return false;
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    while(~scanf("%d%d%d%lf", &n, &m, &s, &v)) {
        memset(cost, 0, sizeof cost);
        rep(i, 1, n) G[i].clear();
        rep(i, 1, m) {
            scanf("%d%d%lf%lf%lf%lf", &a, &b, &r1, &c1, &r2, &c2);
            cost[a][b].r = r1; cost[a][b].c = c1;
            cost[b][a].r = r2; cost[b][a].c = c2;
            G[a].push_back(b); G[b].push_back(a);
        }

        printf(solve()?"YES\n":"NO\n");
    }

    return 0;
}

F - Wormholes

 POJ - 3259

While exploring his many farms, Farmer John has discovered a number of amazing wormholes. A wormhole is very peculiar because it is a one-way path that delivers you to its destination at a time that is BEFORE you entered the wormhole! Each of FJ's farms comprises N (1 ≤ N ≤ 500) fields conveniently numbered 1..N, M (1 ≤ M≤ 2500) paths, and W (1 ≤ W ≤ 200) wormholes.

As FJ is an avid time-traveling fan, he wants to do the following: start at some field, travel through some paths and wormholes, and return to the starting field a time before his initial departure. Perhaps he will be able to meet himself :) .

To help FJ find out whether this is possible or not, he will supply you with complete maps to F (1 ≤ F ≤ 5) of his farms. No paths will take longer than 10,000 seconds to travel and no wormhole can bring FJ back in time by more than 10,000 seconds.

Input

Line 1: A single integer, F. F farm descriptions follow. 
Line 1 of each farm: Three space-separated integers respectively: N, M, and W 
Lines 2.. M+1 of each farm: Three space-separated numbers ( S, E, T) that describe, respectively: a bidirectional path between S and E that requires T seconds to traverse. Two fields might be connected by more than one path. 
Lines M+2.. M+ W+1 of each farm: Three space-separated numbers ( S, E, T) that describe, respectively: A one way path from S to E that also moves the traveler backT seconds.

Output

Lines 1.. F: For each farm, output "YES" if FJ can achieve his goal, otherwise output "NO" (do not include the quotes).

Sample Input

2
3 3 1
1 2 2
1 3 4
2 3 1
3 1 3
3 2 1
1 2 3
2 3 4
3 1 8

Sample Output

NO
YES

Hint

For farm 1, FJ cannot travel back in time. 
For farm 2, FJ could travel back in time by the cycle 1->2->3->1, arriving back at his starting location 1 second before he leaves. He could start from anywhere on the cycle to accomplish this.

 

找负环的板子题。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 510
#define M 3645
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int t, n, m, w;
struct Edge {
  int v, w;
};
vector G[N];
int d[N];

bool solve()
{
    memset(d, 0, sizeof d);

    rep(k, 1, n) {
        rep(i, 1, n) {
            for(int j = 0; j < G[i].size(); j++) {
                Edge & e = G[i][j];
                if(d[e.v] > d[i] + e.w) {
                    d[e.v] = d[i] + e.w;
                    if(k == n) return true;
                }
            }
        }
    }
    return false;
}

int main()
{
    #ifndef ONLINE_JUDGE
     freopen("data.txt", "r", stdin);
    #endif

    scanf("%d", &t);
    while(t--) {
        scanf("%d%d%d", &n, &m, &w);
        rep(i, 1, n) G[i].clear();
        Edge e;
        int u;
        rep(i, 1, m) {
            scanf("%d%d%d", &u, &e.v, &e.w);
            G[u].push_back(e);
            swap(u, e.v);
            G[u].push_back(e);
        }
        rep(i, 1, w) {
            scanf("%d%d%d", &u, &e.v, &e.w);
            e.w = -e.w;
            G[u].push_back(e);
        }

        printf(solve()?"YES\n":"NO\n");
    }

    return 0;
}

G - MPI Maelstrom

 POJ - 1502

BIT has recently taken delivery of their new supercomputer, a 32 processor Apollo Odyssey distributed shared memory machine with a hierarchical communication subsystem. Valentine McKee's research advisor, Jack Swigert, has asked her to benchmark the new system. 
``Since the Apollo is a distributed shared memory machine, memory access and communication times are not uniform,'' Valentine told Swigert. ``Communication is fast between processors that share the same memory subsystem, but it is slower between processors that are not on the same subsystem. Communication between the Apollo and machines in our lab is slower yet.'' 

``How is Apollo's port of the Message Passing Interface (MPI) working out?'' Swigert asked. 

``Not so well,'' Valentine replied. ``To do a broadcast of a message from one processor to all the other n-1 processors, they just do a sequence of n-1 sends. That really serializes things and kills the performance.'' 

``Is there anything you can do to fix that?'' 

``Yes,'' smiled Valentine. ``There is. Once the first processor has sent the message to another, those two can then send messages to two other hosts at the same time. Then there will be four hosts that can send, and so on.'' 

``Ah, so you can do the broadcast as a binary tree!'' 

``Not really a binary tree -- there are some particular features of our network that we should exploit. The interface cards we have allow each processor to simultaneously send messages to any number of the other processors connected to it. However, the messages don't necessarily arrive at the destinations at the same time -- there is a communication cost involved. In general, we need to take into account the communication costs for each link in our network topologies and plan accordingly to minimize the total time required to do a broadcast.''

Input

The input will describe the topology of a network connecting n processors. The first line of the input will be n, the number of processors, such that 1 <= n <= 100. 

The rest of the input defines an adjacency matrix, A. The adjacency matrix is square and of size n x n. Each of its entries will be either an integer or the character x. The value of A(i,j) indicates the expense of sending a message directly from node i to node j. A value of x for A(i,j) indicates that a message cannot be sent directly from node i to node j. 

Note that for a node to send a message to itself does not require network communication, so A(i,i) = 0 for 1 <= i <= n. Also, you may assume that the network is undirected (messages can go in either direction with equal overhead), so that A(i,j) = A(j,i). Thus only the entries on the (strictly) lower triangular portion of A will be supplied. 

The input to your program will be the lower triangular section of A. That is, the second line of input will contain one entry, A(2,1). The next line will contain two entries, A(3,1) and A(3,2), and so on.

Output

Your program should output the minimum communication time required to broadcast a message from the first processor to all the other processors.

Sample Input

5
50
30 5
100 20 50
10 x x 10

Sample Output

35
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 11000
#define M 3645
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int t, n;
struct edge{
  int v, w;
};
vector G[N];
int d[N];

void dijkstra()
{
    priority_queue< P, vector
, greater
 > que;
    memset(d, INF, sizeof d);
    d[n] = 0;
    que.push(P(0, n));

    while(!que.empty()) {
        P h = que.top(); que.pop();

        int v = h.se;
        if(d[v] < h.fi) continue;

        for(int i = 0; i < G[v].size(); i++) {
            edge e = G[v][i];
            if(d[e.v] > d[v] + e.w)
                d[e.v] = d[v] + e.w, que.push(P(d[e.v], e.v));
        }
    }
}

int getn()
{
    char ch = 'x';
    cin >> ch;
    if(ch == 'x') return -1;
    int ret = ch - '0';
    while((ch = getchar()) != ' ' && ch != '\n' && ch != EOF) {
        ret = ret * 10 + ch - '0';
    }
    return ret;
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    scanf("%d", &n);

    int w;
    edge e;
    rep(i, 2, n) rep(j, 1, i - 1){
        if((w = getn()) > 0) {
            e.v = j; e.w = w;
            G[i].push_back(e);
            e.v = i;
            G[j].push_back(e);
        }
    }

    dijkstra();
    int ans = 0;
    rep(i, 2, n) ans = max(ans, d[i]);

    printf("%d\n", ans);

    return 0;
}

H - Cow Contest

 POJ - 3660

N (1 ≤ N ≤ 100) cows, conveniently numbered 1..N, are participating in a programming contest. As we all know, some cows code better than others. Each cow has a certain constant skill rating that is unique among the competitors.

The contest is conducted in several head-to-head rounds, each between two cows. If cow A has a greater skill level than cow B (1 ≤ A ≤ N; 1 ≤ B ≤ N; A ≠ B), then cow A will always beat cow B.

Farmer John is trying to rank the cows by skill level. Given a list the results of M(1 ≤ M ≤ 4,500) two-cow rounds, determine the number of cows whose ranks can be precisely determined from the results. It is guaranteed that the results of the rounds will not be contradictory.

Input

* Line 1: Two space-separated integers: N and M
* Lines 2..M+1: Each line contains two space-separated integers that describe the competitors and results (the first integer, A, is the winner) of a single round of competition: A and B

Output

* Line 1: A single integer representing the number of cows whose ranks can be determined
　

Sample Input

5 5
4 3
4 2
3 2
1 2
2 5

Sample Output

2

一个点能不能确定要看它和所有其它点之间有没有确定关系，而所有点之间的关系可以Floyed来求。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 110
#define M 3645
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int n, m, a, b;
bool g[N][N];

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    while(~scanf("%d%d", &n, &m)) {
        rep(i, 1, m) {
            scanf("%d%d", &a, &b);
            g[a][b] = true;
        }

        rep(k, 1, n) rep(i, 1, n) rep(j, 1, n) {
            g[i][j] = g[i][j]|(g[i][k]&g[k][j]);
        }

        int ans = 0;
        rep(i, 1, n) {
            int ret = 0;
            rep(j, 1, n) ret += g[i][j]|g[j][i];
            if(ret == n - 1) ans++;
        }

        printf("%d\n", ans);
    }

    return 0;
}

I - Arbitrage

 POJ - 2240

Arbitrage is the use of discrepancies in currency exchange rates to transform one unit of a currency into more than one unit of the same currency. For example, suppose that 1 US Dollar buys 0.5 British pound, 1 British pound buys 10.0 French francs, and 1 French franc buys 0.21 US dollar. Then, by converting currencies, a clever trader can start with 1 US dollar and buy 0.5 * 10.0 * 0.21 = 1.05 US dollars, making a profit of 5 percent. 

Your job is to write a program that takes a list of currency exchange rates as input and then determines whether arbitrage is possible or not. 

Input

The input will contain one or more test cases. Om the first line of each test case there is an integer n (1<=n<=30), representing the number of different currencies. The next n lines each contain the name of one currency. Within a name no spaces will appear. The next line contains one integer m, representing the length of the table to follow. The last m lines each contain the name ci of a source currency, a real number rij which represents the exchange rate from ci to cj and a name cj of the destination currency. Exchanges which do not appear in the table are impossible. 
Test cases are separated from each other by a blank line. Input is terminated by a value of zero (0) for n.

Output

For each test case, print one line telling whether arbitrage is possible or not in the format "Case case: Yes" respectively "Case case: No".

Sample Input

3
USDollar
BritishPound
FrenchFranc
3
USDollar 0.5 BritishPound
BritishPound 10.0 FrenchFranc
FrenchFranc 0.21 USDollar

3
USDollar
BritishPound
FrenchFranc
6
USDollar 0.5 BritishPound
USDollar 4.9 FrenchFranc
BritishPound 10.0 FrenchFranc
BritishPound 1.99 USDollar
FrenchFranc 0.09 BritishPound
FrenchFranc 0.19 USDollar

0

Sample Output

Case 1: Yes
Case 2: No

判断正环。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 40
#define M 3645
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int n, m;
map mp;
string c1, c2, c;
double r, g[N][N];
double d[N];

bool solve()
{
    memset(d, 0, sizeof d);
    d[1] = 1;

    rep(k, 1, n) {
        rep(i, 1, n) rep(j, 1, n) if(g[i][j] > eps) {
            if(d[j] < d[i] * g[i][j]) {
                d[j] = d[i] * g[i][j];
                if(k == n) return true;
            }
        }
    }
    return false;
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    int t = 0;
    while(~scanf("%d", &n) && n) {
        rep(i, 1, n) {
            cin >> c;
            mp[c] = i;
        }
        scanf("%d", &m);
        memset(g, 0, sizeof g);
        rep(i, 1, m){
            cin >> c1 >> r >> c2;
            g[mp[c1]][mp[c2]] = r;
         //    cout << c1 << ' ' <

J - Invitation Cards

 POJ - 1511

In the age of television, not many people attend theater performances. Antique Comedians of Malidinesia are aware of this fact. They want to propagate theater and, most of all, Antique Comedies. They have printed invitation cards with all the necessary information and with the programme. A lot of students were hired to distribute these invitations among the people. Each student volunteer has assigned exactly one bus stop and he or she stays there the whole day and gives invitation to people travelling by bus. A special course was taken where students learned how to influence people and what is the difference between influencing and robbery. 

The transport system is very special: all lines are unidirectional and connect exactly two stops. Buses leave the originating stop with passangers each half an hour. After reaching the destination stop they return empty to the originating stop, where they wait until the next full half an hour, e.g. X:00 or X:30, where 'X' denotes the hour. The fee for transport between two stops is given by special tables and is payable on the spot. The lines are planned in such a way, that each round trip (i.e. a journey starting and finishing at the same stop) passes through a Central Checkpoint Stop (CCS) where each passenger has to pass a thorough check including body scan. 

All the ACM student members leave the CCS each morning. Each volunteer is to move to one predetermined stop to invite passengers. There are as many volunteers as stops. At the end of the day, all students travel back to CCS. You are to write a computer program that helps ACM to minimize the amount of money to pay every day for the transport of their employees. 

Input

The input consists of N cases. The first line of the input contains only positive integer N. Then follow the cases. Each case begins with a line containing exactly two integers P and Q, 1 <= P,Q <= 1000000. P is the number of stops including CCS and Q the number of bus lines. Then there are Q lines, each describing one bus line. Each of the lines contains exactly three numbers - the originating stop, the destination stop and the price. The CCS is designated by number 1. Prices are positive integers the sum of which is smaller than 1000000000. You can also assume it is always possible to get from any stop to any other stop.

Output

For each case, print one line containing the minimum amount of money to be paid each day by ACM for the travel costs of its volunteers.

Sample Input

2
2 2
1 2 13
2 1 33
4 6
1 2 10
2 1 60
1 3 20
3 4 10
2 4 5
4 1 50

Sample Output

46
210

和上面某题目一样，反过来建图就好了。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 1000010
#define M 3645
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int t, n, m, a[N], b[N], c[N];
struct Edge{
  int v, w, nex;
}edge[N];
int tot, fir[N];
void init()
{
    tot = 0;
    memset(fir, -1, sizeof fir);
}
void add(int u, int v, int w)
{
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].nex = fir[u];
    fir[u] = tot++;
}
ll d[N], ans;
int que[N * 3];
bool vis[N];
//
//void spfa()
//{
//    int head = 0, tail = 0;
//    memset(d, INF, sizeof d);
//    memset(vis, false, sizeof vis);
//    d[1] = 0;
//    vis[1] = true;
//    que[tail++] = 1;
//
//    while(head < tail) {
//        int v = que[head++];
//        vis[v] = false;
//        for(int i = fir[v]; i != -1; i = edge[i].nex) {
//            if(d[edge[i].v] > d[v] + edge[i].w) {
//                d[edge[i].v] = d[v] + edge[i].w;
//                if(!vis[edge[i].v]) {
//                    vis[edge[i].v] = true;
//                    que[tail++] = edge[i].v;
//                }
//            }
//        }
//    }
//}


void spfa()
{
    int l = 0;
    memset(d, INF, sizeof d);
    memset(vis, false, sizeof vis);
    d[1] = 0;
    vis[1] = true;
    que[l++] = 1;

    while(l) {
        int v = que[--l];
        vis[v] = false;
        for(int i = fir[v]; i != -1; i = edge[i].nex) {
            if(d[edge[i].v] > d[v] + edge[i].w) {
                d[edge[i].v] = d[v] + edge[i].w;
                if(!vis[edge[i].v]) {
                    vis[edge[i].v] = true;
                    que[l++] = edge[i].v;
                }
            }
        }
    }
}


int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    scanf("%d", &t);
    while(t--) {
        scanf("%d%d", &n, &m);
        init();
        rep(i, 1, m) {
            scanf("%d%d%d", &a[i], &b[i], &c[i]);
            add(a[i], b[i], c[i]);
        }
        spfa();
        ans = 0;
        rep(i, 2, n) ans += d[i];
        init();
        rep(i, 1, m) add(b[i], a[i], c[i]);
        spfa();
        rep(i, 2, n) ans += d[i];
        printf("%lld\n", ans);
    }

    return 0;
}

K - Candies

 POJ - 3159 

During the kindergarten days, flymouse was the monitor of his class. Occasionally the head-teacher brought the kids of flymouse’s class a large bag of candies and had flymouse distribute them. All the kids loved candies very much and often compared the numbers of candies they got with others. A kid A could had the idea that though it might be the case that another kid B was better than him in some aspect and therefore had a reason for deserving more candies than he did, he should never get a certain number of candies fewer than B did no matter how many candies he actually got, otherwise he would feel dissatisfied and go to the head-teacher to complain about flymouse’s biased distribution.

snoopy shared class with flymouse at that time. flymouse always compared the number of his candies with that of snoopy’s. He wanted to make the difference between the numbers as large as possible while keeping every kid satisfied. Now he had just got another bag of candies from the head-teacher, what was the largest difference he could make out of it?

Input

The input contains a single test cases. The test cases starts with a line with two integers N and M not exceeding 30 000 and 150 000 respectively. N is the number of kids in the class and the kids were numbered 1 through N. snoopy and flymouse were always numbered 1 and N. Then follow M lines each holding three integers A, B and cin order, meaning that kid A believed that kid B should never get over c candies more than he did.

Output

Output one line with only the largest difference desired. The difference is guaranteed to be finite.

Sample Input

2 2
1 2 5
2 1 4

Sample Output

5

Hint

32-bit signed integer type is capable of doing all arithmetic.

emmmmmmmmm在北大做过，是差分约束的题。不是很能理解spfa+stack和spfa+queue的区别。这俩应该有各自适合的图，百度也没百度到什么，有说stack判负环快，其他的我猜大概细细长长的适合栈吧。。。。。怎么这题就只能用stack呢。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 30010
#define M 150010
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int t, n, m, a, b, c;
struct Edge{
  int v, w, nex;
}edge[M];
int tot, fir[N];
void init()
{
    tot = 0;
    memset(fir, -1, sizeof fir);
}
void add(int u, int v, int w)
{
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].nex = fir[u];
    fir[u] = tot++;
}
ll d[N], ans;
int que[10000000];
bool vis[N];

void spfa()
{
    int l = 0;
    memset(d, INF, sizeof d);
    memset(vis, false, sizeof vis);
    d[1] = 0;
    vis[1] = true;
    que[l++] = 1;

    while(l) {
        int v = que[--l];
        vis[v] = false;
        for(int i = fir[v]; i != -1; i = edge[i].nex) {
            if(d[edge[i].v] > d[v] + edge[i].w) {
                d[edge[i].v] = d[v] + edge[i].w;
                if(!vis[edge[i].v]) {
                    vis[edge[i].v] = true;
                    que[l++] = edge[i].v;
                }
            }
        }
    }
}

//void spfa()
//{
//    int head = 0, tail = 0;
//    memset(d, INF, sizeof d);
//    memset(vis, false, sizeof vis);
//    d[1] = 0;
//    vis[1] = true;
//    que[tail++] = 1;
//
//    while(head != tail) {
//        int v = que[head++];
//        if(head >= 1000000) head = 0;
//        vis[v] = false;
//        for(int i = fir[v]; i != -1; i = edge[i].nex) {
//            if(d[edge[i].v] > d[v] + edge[i].w) {
//                d[edge[i].v] = d[v] + edge[i].w;
//                if(!vis[edge[i].v]) {
//                    vis[edge[i].v] = true;
//                    que[tail++] = edge[i].v;
//                    if(tail >= 1000000) tail = 0;
//                }
//            }
//        }
//    }
//}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    while(~scanf("%d%d", &n, &m)) {
        init();
        rep(i, 1, m) {
            scanf("%d%d%d", &a, &b, &c);
            add(a, b, c);
        }
        spfa();
        printf("%lld\n", d[n]);
    }

    return 0;
}

L - Subway

 POJ - 2502

You have just moved from a quiet Waterloo neighbourhood to a big, noisy city. Instead of getting to ride your bike to school every day, you now get to walk and take the subway. Because you don't want to be late for class, you want to know how long it will take you to get to school. 
You walk at a speed of 10 km/h. The subway travels at 40 km/h. Assume that you are lucky, and whenever you arrive at a subway station, a train is there that you can board immediately. You may get on and off the subway any number of times, and you may switch between different subway lines if you wish. All subway lines go in both directions.

Input

Input consists of the x,y coordinates of your home and your school, followed by specifications of several subway lines. Each subway line consists of the non-negative integer x,y coordinates of each stop on the line, in order. You may assume the subway runs in a straight line between adjacent stops, and the coordinates represent an integral number of metres. Each line has at least two stops. The end of each subway line is followed by the dummy coordinate pair -1,-1. In total there are at most 200 subway stops in the city.

Output

Output is the number of minutes it will take you to get to school, rounded to the nearest minute, taking the fastest route.

Sample Input

0 0 10000 1000
0 200 5000 200 7000 200 -1 -1 
2000 600 5000 600 10000 600 -1 -1

Sample Output

21

这一题难在建图上——同一条线上相邻的车站连接，然后所有点之间建立人走的路。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 210
#define M 150010
const double INF = 1e30;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

double cost[N + 1][N + 1];
struct Node {
  double x, y;
}node[N];
double getd(Node a, Node b){
    return sqrt((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));
}
double d[N];
bool vis[N];

void dijkstra(int n, int s)
{
    rep(i, 1, n) {
        d[i] = INF;
        vis[i] = false;
    }

    d[s] = 0;
    rep(k, 1, n) {
        int p = -1;
        double minc = INF;
        rep(i, 1, n) if(!vis[i] && d[i] < minc) {
            minc = d[i]; p = i;
        }
        if(p == -1) break;
        vis[p] = true;
        rep(i, 1, n) {
            if(!vis[i] && d[p] + cost[p][i] < d[i]) {
                d[i] = d[p] + cost[p][i];
            }
        }
    }
}
void init()
{
    rep(i, 1, N) rep(j, 1, N)
        cost[i][j] = (i == j?0.0:INF);
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    const double v1 = 10000.0 / 60, v2 = 40000.0 / 60;
    while(~scanf("%lf%lf%lf%lf", &node[1].x, &node[1].y, &node[2].x, &node[2].y)) {
        int n = 2, cnt = 3, x, y;
        init();
        while(~scanf("%d%d", &x, &y)) {
            if(x == -1 && y == -1) {
                cnt = n + 1; continue;
            }
            n++;
            node[n].x = x; node[n].y = y;
            if(n != cnt) {
                cost[n][n - 1] = cost[n - 1][n] = min(cost[n][n - 1], getd(node[n], node[n - 1]) / v2);
            }
            //cout << cost[n][n - 1] <

M - 昂贵的聘礼

 POJ - 1062

年轻的探险家来到了一个印第安部落里。在那里他和酋长的女儿相爱了，于是便向酋长去求亲。酋长要他用10000个金币作为聘礼才答应把女儿嫁给他。探险家拿不出这么多金币，便请求酋长降低要求。酋长说："嗯，如果你能够替我弄到大祭司的皮袄，我可以只要8000金币。如果你能够弄来他的水晶球，那么只要5000金币就行了。"探险家就跑到大祭司那里，向他要求皮袄或水晶球，大祭司要他用金币来换，或者替他弄来其他的东西，他可以降低价格。探险家于是又跑到其他地方，其他人也提出了类似的要求，或者直接用金币换，或者找到其他东西就可以降低价格。不过探险家没必要用多样东西去换一样东西，因为不会得到更低的价格。探险家现在很需要你的帮忙，让他用最少的金币娶到自己的心上人。另外他要告诉你的是，在这个部落里，等级观念十分森严。地位差距超过一定限制的两个人之间不会进行任何形式的直接接触，包括交易。他是一个外来人，所以可以不受这些限制。但是如果他和某个地位较低的人进行了交易，地位较高的的人不会再和他交易，他们认为这样等于是间接接触，反过来也一样。因此你需要在考虑所有的情况以后给他提供一个最好的方案。 
为了方便起见，我们把所有的物品从1开始进行编号，酋长的允诺也看作一个物品，并且编号总是1。每个物品都有对应的价格P，主人的地位等级L，以及一系列的替代品Ti和该替代品所对应的"优惠"Vi。如果两人地位等级差距超过了M，就不能"间接交易"。你必须根据这些数据来计算出探险家最少需要多少金币才能娶到酋长的女儿。 

Input

输入第一行是两个整数M，N（1 <= N <= 100），依次表示地位等级差距限制和物品的总数。接下来按照编号从小到大依次给出了N个物品的描述。每个物品的描述开头是三个非负整数P、L、X（X < N），依次表示该物品的价格、主人的地位等级和替代品总数。接下来X行每行包括两个整数T和V，分别表示替代品的编号和"优惠价格"。

Output

输出最少需要的金币数。

Sample Input

1 4
10000 3 2
2 8000
3 5000
1000 2 1
4 200
3000 2 1
4 200
50 2 0

Sample Output

5250

本来我天真的以为点ab只要不和起始点相差超过m并且ab之间不超过m就能建边，不过这样就会出现矛盾的情况（比源点大和比源点小的之间就可能gg）。解法是枚举一个长度为m的等级区间。源点的等级在区间里。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 110
#define M 150010
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int n, m;
int g[N][N];
struct Node {
  int p, l, x;
  vector
 vct;
}node[N];
int d[N], ans;
bool vis[N];

void dijkstra()
{
    memset(d, INF, sizeof d);
    memset(vis, false, sizeof vis);
    d[1] = 0;
    rep(k, 1, n) {
        int p = -1;
        int minc = INF;
        rep(i, 1, n) if(!vis[i] && d[i] < minc) {
            minc = d[i]; p = i;
        }
        if(p == -1) break;
        vis[p] = true;
        rep(i, 1, n) {
            if(!vis[i] && d[p] + g[p][i] < d[i]) {
                d[i] = d[p] + g[p][i];
            }
        }
    }
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    scanf("%d%d", &m, &n);
    n++;
    rep(i, 2, n) {
        scanf("%d%d%d", &node[i].p, &node[i].l, &node[i].x);
        rep(j, 1, node[i].x) {
            int t, v;
            scanf("%d%d", &t, &v);
            node[i].vct.push_back(P(t + 1, v));
        }
    }

    ans = INF;
    for(int k = max(0, node[2].l - m); k <= node[2].l; k++) {
        memset(g, INF, sizeof g);
        rep(i, 1, n) g[i][i] = 0;
        int L = k, R = k + m;
        rep(i, 2, n) g[1][i] = node[i].p;
        rep(i, 2, n) {
            rep(j, 0, node[i].x - 1) {
                if(node[i].l < L || node[i].l > R) continue;
                P h = node[i].vct[j];
                int t = h.fi, v = h.se;
                if(node[t].l >= L && node[t].l <= R) {
                     g[t][i] = v;
                }
            }
        }
        dijkstra();
        ans = min(ans, d[2]);
    }

    printf("%d\n", ans);

    return 0;
}

N - Tram

 POJ - 1847

Tram network in Zagreb consists of a number of intersections and rails connecting some of them. In every intersection there is a switch pointing to the one of the rails going out of the intersection. When the tram enters the intersection it can leave only in the direction the switch is pointing. If the driver wants to go some other way, he/she has to manually change the switch. 

When a driver has do drive from intersection A to the intersection B he/she tries to choose the route that will minimize the number of times he/she will have to change the switches manually. 

Write a program that will calculate the minimal number of switch changes necessary to travel from intersection A to intersection B. 

Input

The first line of the input contains integers N, A and B, separated by a single blank character, 2 <= N <= 100, 1 <= A, B <= N, N is the number of intersections in the network, and intersections are numbered from 1 to N. 

Each of the following N lines contain a sequence of integers separated by a single blank character. First number in the i-th line, Ki (0 <= Ki <= N-1), represents the number of rails going out of the i-th intersection. Next Ki numbers represents the intersections directly connected to the i-th intersection.Switch in the i-th intersection is initially pointing in the direction of the first intersection listed. 

Output

The first and only line of the output should contain the target minimal number. If there is no route from A to B the line should contain the integer "-1".

Sample Input

3 2 1
2 2 3
2 3 1
2 1 2

Sample Output

0

建图是除了第一个为0其他的值都为1.

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 110
#define M 150010
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int n, a, b, num, c;
int g[N][N];
int d[N], ans;
bool vis[N];

void dijkstra()
{
    memset(d, INF, sizeof d);
    memset(vis, false, sizeof vis);
    d[a] = 0;

    rep(k, 1, n) {
        int p = -1;
        int minc = INF;
        rep(i, 1, n) if(!vis[i] && d[i] < minc) {
            minc = d[i]; p = i;
        }

        if(p == -1) break;
        vis[p] = true;
        rep(i, 1, n) {
            if(!vis[i] && d[p] + g[p][i] < d[i]) {
                d[i] = d[p] + g[p][i];
            }
        }
    }
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    memset(g, INF, sizeof g);
    rep(i, 1, N - 1) g[i][i] = 0;
    scanf("%d%d%d", &n, &a, &b);
    rep(i, 1, n) {
        scanf("%d", &num);
        if(num > 0) scanf("%d", &c);
        else continue;
        g[i][c] = 0;
        rep(j, 2, num) {
            scanf("%d", &c);
            g[i][c] = 1;
        }
    }
//    rep(i, 1, n) rep(j, 1, n)
//        cout << i <<' ' <

O - Extended Traffic

 LightOJ - 1074

Dhaka city is getting crowded and noisy day by day. Certain roads always remain blocked in congestion. In order to convince people avoid shortest routes, and hence the crowded roads, to reach destination, the city authority has made a new plan. Each junction of the city is marked with a positive integer (≤ 20) denoting the busyness of the junction. Whenever someone goes from one junction (the source junction) to another (the destination junction), the city authority gets the amount (busyness of destination - busyness of source)3 (that means the cube of the difference) from the traveler. The authority has appointed you to find out the minimum total amount that can be earned when someone intelligent goes from a certain junction (the zero point) to several others.

Input

Input starts with an integer T (≤ 50), denoting the number of test cases.

Each case contains a blank line and an integer n (1 < n ≤ 200) denoting the number of junctions. The next line contains nintegers denoting the busyness of the junctions from 1 to n respectively. The next line contains an integer m, the number of roads in the city. Each of the next m lines (one for each road) contains two junction-numbers (source, destination) that the corresponding road connects (all roads are unidirectional). The next line contains the integer q, the number of queries. The next q lines each contain a destination junction-number. There can be at most one direct road from a junction to another junction.

Output

For each case, print the case number in a single line. Then print q lines, one for each query, each containing the minimum total earning when one travels from junction 1 (the zero point) to the given junction. However, for the queries that gives total earning less than 3, or if the destination is not reachable from the zero point, then print a '?'.

Sample Input

2

 

5

6 7 8 9 10

6

1 2

2 3

3 4

1 5

5 4

4 5

2

4

5

 

2

10 10

1

1 2

1

2

Sample Output

Case 1:

3

4

Case 2:

?

本来就不会用spfa判断负环，要判断一个点是否连着这个负环就更不会了，要靠深搜。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 210
#define M 15010
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int n, m, a, b, w[N], q, c;
int d[N], ans;
bool vis[N];

struct Edge {
  int v, w, nex;
}edge[M];
int tot, fir[N], que[2000000], cnt[N];
bool cir[N];

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

void add(int u, int v, int w)
{
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].nex = fir[u];
    fir[u] = tot++;
}

void dfs(int s)
{
    cir[s] = true;
    for(int i = fir[s]; i != -1; i = edge[i].nex) {
        if(!cir[edge[i].v]) dfs(edge[i].v);
    }
}

void spfa()
{
    int head = 0, tail = 0;
    memset(d, INF, sizeof d);
    memset(cnt, 0, sizeof cnt);
    memset(vis, false, sizeof vis);
    memset(cir, false, sizeof cir);
    que[tail++] = 1;
    vis[1] = true;
    d[1] = 0;

    while(head < tail) {
        int h = que[head++];
        vis[h] = false;

        for(int i = fir[h]; i != -1; i = edge[i].nex) {
            if(!cir[edge[i].v] && d[edge[i].v] > d[h] + edge[i].w) {
                d[edge[i].v] = d[h] + edge[i].w;

                if(!vis[edge[i].v]) {
                    que[tail++] = edge[i].v;
                    vis[edge[i].v] = true;

                    cnt[edge[i].v]++;
                    if(cnt[edge[i].v] > n) {
                        dfs(edge[i].v);
                    }
                }
            }
        }
    }
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    int t;
    scanf("%d", &t);
    rep(Case, 1, t) {
        scanf("%d", &n);
        rep(i, 1, n) scanf("%d", &w[i]);
        scanf("%d", &m);
        init();
        rep(i, 1, m) {
            scanf("%d%d", &a, &b);
            add(a, b, (w[b]-w[a])*(w[a]-w[b])*(w[a]-w[b]));
        }
        spfa();
        scanf("%d", &q);
        printf("Case %d:\n", Case);
        while(q--) {
            scanf("%d", &c);
            if(d[c] == INF || d[c] < 3 || cir[c]) printf("?\n");
            else printf("%d\n", d[c]);
        }
    }

    return 0;
}

P - The Shortest Path in Nya Graph

 HDU - 4725

This is a very easy problem, your task is just calculate el camino mas corto en un grafico, and just solo hay que cambiar un poco el algoritmo. If you do not understand a word of this paragraph, just move on. 
The Nya graph is an undirected graph with "layers". Each node in the graph belongs to a layer, there are N nodes in total. 
You can move from any node in layer x to any node in layer x + 1, with cost C, since the roads are bi-directional, moving from layer x + 1 to layer x is also allowed with the same cost. 
Besides, there are M extra edges, each connecting a pair of node u and v, with cost w. 
Help us calculate the shortest path from node 1 to node N.

Input

The first line has a number T (T <= 20) , indicating the number of test cases. 
For each test case, first line has three numbers N, M (0 <= N, M <= 10 5) and C(1 <= C <= 10 3), which is the number of nodes, the number of extra edges and cost of moving between adjacent layers. 
The second line has N numbers l i (1 <= l i <= N), which is the layer of i th node belong to. 
Then come N lines each with 3 numbers, u, v (1 <= u, v < =N, u <> v) and w (1 <= w <= 10 4), which means there is an extra edge, connecting a pair of node u and v, with cost w.

Output

For test case X, output "Case #X: " first, then output the minimum cost moving from node 1 to node N. 
If there are no solutions, output -1.

Sample Input

2
3 3 3
1 3 2
1 2 1
2 3 1
1 3 3

3 3 3
1 3 2
1 2 2
2 3 2
1 3 4

Sample Output

Case #1: 2
Case #2: 3

这题的朴素建图(n^2)会超时，方法是把层抽象成点，点到相邻层只需要链接该点到相邻层抽象出的点，而不需要把该点一一和相邻所有点相连。然后每层要和自己的层所在的相连，边赋值为0.

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 100010
#define M 1500100
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int t, n, m, a, b, c, u, v, w;
//vector layer[N];
struct Edge{
  int v, w, nex;
}edge[M];
int tot, fir[M];
void init()
{
    tot = 0;
    memset(fir, -1, sizeof fir);
}
void add(int u, int v, int w)
{
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].nex = fir[u];
    fir[u] = tot++;
}
int d[N * 2];
bool vis[N * 2];
queue que;

void spfa()
{
    while(!que.empty()) que.pop();
    memset(d, INF, sizeof d);
    memset(vis, false, sizeof vis);
    d[1] = 0;
    vis[1] = true;
    que.push(1);

    while(!que.empty()) {
        int v = que.front(); que.pop();
        vis[v] = false;
        for(int i = fir[v]; i != -1; i = edge[i].nex) {
            if(d[edge[i].v] > d[v] + edge[i].w) {
                d[edge[i].v] = d[v] + edge[i].w;
                if(!vis[edge[i].v]) {
                    vis[edge[i].v] = true;
                    que.push(edge[i].v);
                }
            }
        }
    }
}


int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    scanf("%d", &t);

    rep(Case, 1, t) {
        scanf("%d%d%d", &n, &m, &c);

        init();
        rep(i, 1, n) {
            scanf("%d", &a);
            add(a + n, i, 0);
            if(a > 1) add(i, a + n - 1, c);
            if(a < n) add(i, a + n + 1, c);
        }
        rep(i, 1, m) {
            scanf("%d%d%d", &u, &v, &w);
            add(u, v, w);
            add(v, u, w);
        }
        spfa();
        if(d[n] == INF) d[n] = -1;
        printf("Case #%d: %d\n", Case, d[n]);
    }

    return 0;
}

Q - Marriage Match IV

 HDU - 3416 

Do not sincere non-interference。 
Like that show, now starvae also take part in a show, but it take place between city A and B. Starvae is in city A and girls are in city B. Every time starvae can get to city B and make a data with a girl he likes. But there are two problems with it, one is starvae must get to B within least time, it's said that he must take a shortest path. Other is no road can be taken more than once. While the city starvae passed away can been taken more than once. 


So, under a good RP, starvae may have many chances to get to city B. But he don't know how many chances at most he can make a data with the girl he likes . Could you help starvae?

Input

The first line is an integer T indicating the case number.(1<=T<=65) 
For each case,there are two integer n and m in the first line ( 2<=n<=1000, 0<=m<=100000 ) ,n is the number of the city and m is the number of the roads. 

Then follows m line ,each line have three integers a,b,c,(1<=a,b<=n,0
At last is a line with two integer A and B(1<=A,B<=N,A!=B), means the number of city A and city B. 
There may be some blank line between each case.

Output

Output a line with a integer, means the chances starvae can get at most.

Sample Input

3
7 8
1 2 1
1 3 1
2 4 1
3 4 1
4 5 1
4 6 1
5 7 1
6 7 1
1 7

6 7
1 2 1
2 3 1
1 3 3
3 4 1
3 5 1
4 6 1
5 6 1
1 6

2 2
1 2 1
1 2 2
1 2

Sample Output

2
1
1

要求出路有多少条，且每条路只能走一次，这就变成网络流了Orz。先把组成最短路的弧找出来（正反向建图找到d1和d2，然后一波操作对每个弧ab能minpath = Wab + d[a] + d[b]的就丢进网络流里去），再在这些弧上跑网络流Orz。

抄了个Kuangbin自己的博客代码，看不懂SAP啊啊啊啊啊啊啊啊啊啊啊啊Orz。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 2010
#define M 2000100
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

//SAP
struct Node {
  int to, nxt, cap;
}edge[M];
int tot, head[N];
int gap[N], dis[N], pre[N], cur[N];
void init()
{
    tot = 0;
    memset(head, -1, sizeof head);
}
void addedge(int u, int v, int w, int rw = 0)
{
    edge[tot].to = v; edge[tot].cap = w;
    edge[tot].nxt = head[u]; head[u] = tot++;
    edge[tot].to = u; edge[tot].cap = rw;
    edge[tot].nxt = head[v]; head[v] = tot++;
}

int sap(int start, int end, int nodenum)
{
    memset(dis, 0, sizeof dis);
    memset(gap, 0, sizeof gap);
    memcpy(cur, head, sizeof head);
    int u = pre[start] = start, maxflow = 0, aug = -1;
    gap[0] = nodenum;
    while(dis[start] < nodenum) {
        loop:
            for(int & i = cur[u]; ~i; i = edge[i].nxt) {
                int v = edge[i].to;
                if(edge[i].cap && dis[u] == dis[v] + 1) {
                    if(aug == -1 || aug > edge[i].cap)
                        aug = edge[i].cap;
                    pre[v] = u;
                    u = v;
                    if(v == end) {
                        maxflow += aug;
                        for(u = pre[u]; v != start; v = u, u = pre[u]) {
                            edge[cur[u]].cap -= aug;
                            edge[cur[u]^1].cap += aug;
                        }
                        aug = -1;
                    }
                    goto loop;
                }
            }
            int mindis = nodenum;
            for(int i = head[u]; ~i; i = edge[i].nxt) {
                int v = edge[i].to;
                if(edge[i].cap && mindis > dis[v]) {
                    cur[u] = i;
                    mindis = dis[v];
                }
            }
            if((--gap[dis[u]]) == 0) break;
            gap[dis[u] = mindis + 1]++;
            u = pre[u];
    }
    return maxflow;
}

//SPFA
int first[N];
bool vis[N];
int cnt[N];
int que[N];
int dist[N];
struct Edge {
  int to, v, nxt;
}edgel[M];
int tt;
void add(int a, int b, int v)
{
    edgel[tt].to = b;
    edgel[tt].v = v;
    edgel[tt].nxt = first[a];
    first[a] = tt++;
}
bool spfa(int start, int n)
{
    int front = 0, rear = 0;
    for(int v = 1; v <= n; v++) {
        if(v == start) {
            que[rear++] = v;
            vis[v] = true;
            cnt[v] = 1;
            dist[v] = 0;
        }
        else {
            vis[v] = false;
            cnt[v] = 0;
            dist[v] = INF;
        }
    }

    while(front < rear) {
        int u = que[front++];
        vis[u] = false;
        if(front >= N) front = 0;
        for(int i = first[u]; ~i; i = edgel[i].nxt) {
            int v = edgel[i].to;
            if(dist[v] > dist[u] + edgel[i].v) {
                dist[v] = dist[u] + edgel[i].v;
                if(!vis[v]) {
                    vis[v] = true;
                    que[rear++] = v;
                    if(rear >= N) rear = 0;
                    if(++cnt[v] > n) return false;
                }
            }
        }
    }
    return false;
}
int a[100010], b[100010], c[100010];
int d1[N], d2[N];

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    int t, n, m;
    scanf("%d", &t);

    while(t--) {
        scanf("%d%d", &n, &m);
        int A, B;
        rep(i, 0, m - 1) {
            scanf("%d%d%d", &a[i], &b[i], &c[i]);
        }
        scanf("%d%d", &A, &B);

        tt = 0;
        memset(first, -1, sizeof first);
        for(int i = 0; i < m; i++)
            add(a[i], b[i], c[i]);
        spfa(A, n);
        memcpy(d1, dist, sizeof dist);
//cout << "aa " <

R - 0 or 1

 HDU - 4370 

Given a n*n matrix C ij (1<=i,j<=n),We want to find a n*n matrix X ij(1<=i,j<=n),which is 0 or 1. 

Besides,X ij meets the following conditions: 

1.X 12+X 13+...X 1n=1 
2.X 1n+X 2n+...X n-1n=1 
3.for each i (1
For example, if n=4,we can get the following equality: 

X 12+X 13+X 14=1 
X 14+X 24+X 34=1 
X 12+X 22+X 32+X 42=X 21+X 22+X 23+X 24 
X 13+X 23+X 33+X 43=X 31+X 32+X 33+X 34 

Now ,we want to know the minimum of ∑C ij*X ij(1<=i,j<=n) you can get. 

Hint


For sample, X 12=X 24=1,all other X ij is 0. 

Input

The input consists of multiple test cases (less than 35 case). 
For each test case ,the first line contains one integer n (1 The next n lines, for each lines, each of which contains n integers, illustrating the matrix C, The j-th integer on i-th line is C ij(0<=C ij<=100000).

Output

For each case, output the minimum of ∑C ij*X ij you can get. 

Sample Input

4
1 2 4 10
2 0 1 1
2 2 0 5
6 3 1 2

Sample Output

3

这题TMD是最短路？？？？？？？？一般题目都是建图建邻接矩阵，这题是给你矩阵你来猜图。。。Orz。X矩阵为1的Xij一定就是点ij相连了，但是什么样的图能让 ∑C ij*X ij(1<=i,j<=n). 最小呢？是最短路的图(由第一和第二个限制条件知道节点1出度为1和节点n的入度为1，由条件三知道其他点出度等于入度，即其他点度数是偶数，又因为握手定理所有点度数和为偶数所以有两个可能——1.节点1连着节点n。2.节点1和节点n都处于环中，俩的度数自身就是偶数)，最短路的图适合第一种可能，第二种要求最小环。求最小环也是门学问，例如求1的最小环，不能从1开始松弛，而是要先人工完成第一步松弛操作把和1连接的点先加进队列，并令d[1]为INF以便于1连接的点来松弛1，如果从1开始松弛d[1]会被初始化为0，gg。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 310
#define M 2000100
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int g[N][N];
int n;
bool vis[N];
int d[N], que[M];

void spfa(int s)
{
    int head = 0, tail = 0;
    d[s] = INF;
    vis[s] = false;
    rep(i, 1, n) if(i != s)
        d[i] = g[s][i], vis[i] = true, que[tail++] = i;

    while(head != tail) {
        int v = que[head++];
        vis[v] = false;
        if(head >= M) head = 0;
        rep(i, 1, n) {
            if(d[i] > d[v] + g[v][i]) {
                d[i] = d[v] + g[v][i];
                if(!vis[i]) {
                    vis[i] = true;
                    que[tail++] = i;
                    if(tail >= M) tail = 0;
                }
            }
        }
    }
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    while(~scanf("%d", &n)) {
        rep(i, 1, n) rep(j, 1, n) scanf("%d", &g[i][j]);
        spfa(1);
        int mind = d[n];
        int a = d[1];
        spfa(n);
        int b = d[n];
        printf("%d\n", min(mind, a + b));
    }

    return 0;
}

S - Layout

 POJ - 3169

Like everyone else, cows like to stand close to their friends when queuing for feed. FJ has N (2 <= N <= 1,000) cows numbered 1..N standing along a straight line waiting for feed. The cows are standing in the same order as they are numbered, and since they can be rather pushy, it is possible that two or more cows can line up at exactly the same location (that is, if we think of each cow as being located at some coordinate on a number line, then it is possible for two or more cows to share the same coordinate). 

Some cows like each other and want to be within a certain distance of each other in line. Some really dislike each other and want to be separated by at least a certain distance. A list of ML (1 <= ML <= 10,000) constraints describes which cows like each other and the maximum distance by which they may be separated; a subsequent list of MD constraints (1 <= MD <= 10,000) tells which cows dislike each other and the minimum distance by which they must be separated. 

Your job is to compute, if possible, the maximum possible distance between cow 1 and cow N that satisfies the distance constraints.

Input

Line 1: Three space-separated integers: N, ML, and MD. 

Lines 2..ML+1: Each line contains three space-separated positive integers: A, B, and D, with 1 <= A < B <= N. Cows A and B must be at most D (1 <= D <= 1,000,000) apart.

Lines ML+2..ML+MD+1: Each line contains three space-separated positive integers: A, B, and D, with 1 <= A < B <= N. Cows A and B must be at least D (1 <= D <= 1,000,000) apart.

Output

Line 1: A single integer. If no line-up is possible, output -1. If cows 1 and N can be arbitrarily far apart, output -2. Otherwise output the greatest possible distance between cows 1 and N.

Sample Input

4 2 1
1 3 10
2 4 20
2 3 3

Sample Output

27

Hint

Explanation of the sample: 

There are 4 cows. Cows #1 and #3 must be no more than 10 units apart, cows #2 and #4 must be no more than 20 units apart, and cows #2 and #3 dislike each other and must be no fewer than 3 units apart. 

The best layout, in terms of coordinates on a number line, is to put cow #1 at 0, cow #2 at 7, cow #3 at 10, and cow #4 at 27.

差分约束原来差不多都能变成最短路，加负号也是很骚了，，学习于这里。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef pair P;
typedef long long ll;
#define N 1010
#define M 2000100
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const double PI = acos(-1);
#define fi first
#define se second
#define rep(i, lll, nnn) for(int i = (lll); i <= (nnn); i++)

int n, ml, md;
struct Edge {
  int v, w, nxt;
}edge[M];
int tot, fir[N];
void init()
{
    tot = 0;
    memset(fir, -1, sizeof fir);
}
void add(int u, int v, int w)
{
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].nxt = fir[u];
    fir[u] = tot++;
}

int d[N], cnt[N], que[N];
bool vis[N];
bool spfa()
{
    memset(d, INF, sizeof d);
    memset(cnt, 0, sizeof cnt);
    memset(vis, false, sizeof vis);
    int head = 0, tail = 0;

    cnt[1] = 1;
    vis[1] = true;
    d[1] = 0;
    que[tail++] = 1;

    while(head != tail) {
        int u = que[head++];
        vis[u] = false;
        if(head >= N) head = 0;
        for(int i = fir[u]; ~i; i = edge[i].nxt) {
            int v = edge[i].v;//cout < d[u] + edge[i].w) {
                d[v] = d[u] + edge[i].w;
                if(!vis[v]) {
                    vis[v] = true;
                    cnt[v]++;
                    if(cnt[v] > n) return false;
                    que[tail++] = v;
                    if(tail >= N) tail = 0;
                }
            }
        }
    }

    return true;
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif

    while(~scanf("%d%d%d", &n, &ml, &md)) {
        init();
        int u, v, w;
        rep(i, 1, ml) {
            scanf("%d%d%d", &u, &v, &w);
            add(u, v, w);
        }
        rep(i, 1, md) {
            scanf("%d%d%d", &u, &v, &w);
            add(v, u, -w);
        }
        if(spfa()) {
            if(d[n] == INF) printf("-2\n");
            else printf("%d\n", d[n]);
        }
        else printf("-1\n");
    }

    return 0;
}

 

你可能感兴趣的:(Kuangbin,最短路)

  • 洛谷P2865 [USACO06NOV] Roadblocks G【C++解法】【次短路问题】 #Dong# c++算法数据结构图论
    /*求次短路问题【spfa解法】本题思路：1.用spfa做，用d1记录从1到n所有点距离点1的最短距离，用d2记录从n到1所有点距离点n的最短距离那么此时d1[n]即为1到n点的最短距离2.遍历每个顶点x，找到它们所指向的点y，利用d1[x](x距离1的最短距离)+d2[y](y距·离n的最短距离)+w[i](x和y的边的权值)因为次短路一定严格大于最短路，而且又是除了最短路以外最小的那个，所以利
  • P3489 [POI2009] WIE-Hexer summ1ts 算法c++图论dijkstra状态压缩
    *原题链接*最短路+状态压缩不愧是POI的题，看题面知道要求加了一些限制的最短路，看数据范围很容易想到状态压缩。求解最短路就用堆优化dijkstra好了。至于状态压缩，我们对原数组再开一维，表示此时“剑的集合”，相应的数组也要多开一维。由于此时的最短路有状态的限制，所以我们要用三元组来维护，如果不想写结构体也可以pair,int>。输入时存储边上的“怪物集合”，以及一个村庄的“铁匠集合”，在来到新
  • P2865 [USACO06NOV] Roadblocks G（洛谷）(次短路) 叶子清不青 算法
    开一个二维数组dis[N][2]分别记录最短路和次短路即可。dijkstra和spfa均可，推荐spfa。//dijkstra#includeusingnamespacestd;constintN=1e5+5;typedeflonglongll;typedefpairPII;intn,m,k;intT;priority_queue,greater>q;structnode{inte,w;};vec
  • P2865 [USACO06NOV]路障Roadblocks dianshu0741
    次短路模板题吧题意已经非常裸了：求无向图的1到n次短路。直接套用最短路(dijkstra)的主要框架。但在这个的基础上添加另外一个数组dist2。走到一条边的时候来三个判定：dist[u]+weightdist[v]&&dist[u]+weightrhs.d;}};voidlink(intu,intv,intw){e[++tot]=(Edges){head[u],v,w};head[u]=tot;
  • Luogu P3489 [POI2009]WIE-Hexer 最短路 躲不过这哀伤
    https://www.luogu.org/problemnew/show/P3489普通的最短路，不过我觉得这个复杂度按道理来说边数不应该是m*2^13吗，不知道是数据比较水还是实际上能证明复杂度低一些。代码如下#includeusingnamespacestd;constintmaxn=210;#definepapairintn,m,p,k;intdis[maxn][8200]={},kn[m
  • P4779 【模板】单源最短路径(堆优化dijkstra) summ1ts 一些模版算法图论最短路dijkstra堆
    堆优化dijkstra，时间复杂度，我个人写习惯的模版。#includeusingnamespacestd;#definePIIpair#definefifirst#definesesecondconstintN=2e5+10;intread(){intx=0,f=1;charch=getchar();while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar()
  • 算法练习——迷宫问题（Java）bfs广搜 流萤点火 算法bfsjava
    问题描述：小明置身于一个迷宫，请你帮小明找出从起点到终点的最短路程。小明只能向上下左右四个方向移动。输入输入包含多组测试数据。输入的第一行是一个整数T，表示有T组测试数据。每组输入的第一行是两个整数N和M（1que,intgx,intgy,intn,intm,char[][]arr){Qq=newQ();q.x=sx;q.y=sy;q.dept=0;que.add(q);//添加intfinish
  • 华南农业大学 OJ数据结构 迷宫问题2(C、C++) 打架戴手表、
    18720迷宫问题（最短路径）时间限制:1000MS代码长度限制:10KB提交次数:0通过次数:0题型:编程题语言:不限定Description迷宫是一个n*m的矩阵，玩家需要迷宫入口(坐标1,1)出发，寻找路径走到出口(n,m)。请判断玩家能否从迷宫中走出，如果能走出迷宫输出，输出最短的路径长度，否则输出-1。输入格式第一行两个整数n和m，代表n行m列。(1typedefstruct{intro
  • 数据结构OJ作业——队列 nnbs 数据结构数据结构poj队列
    POJ3984：http://poj.org/problem?id=3984迷宫，输出最短路径，bfs#include#include#include#includeusingnamespacestd;intmaze[5][5];pairpath[5][5];queue>q;intdx[]={1,-1,0,0};intdy[]={0,0,1,-1};voidbfs(intx,inty){q.pus
  • 运筹学——图论与最短距离（Python实现）(2)，2024年最新Python高级面试framework m0_60575487 2024年程序员学习图论python面试
    适用于wij≥0，给出了从vs到任意一个点vj的最短路。Dijkstra算法是在1959年提出来的。目前公认，在所有的权wij≥0时，这个算法是寻求最短路问题最好的算法。并且，这个算法实际上也给出了寻求从一个始定点vs到任意一个点vj的最短路。2案例1——贪心算法实现==============2.1旅行商问题（TSP）**旅行商问题(TravelingSalesmanProblem，TSP)**
  • 博弈论专题 kuangbin题单（巴什，威佐夫，nim，fib博弈）+SG函数打表 我不是手机 博弈论
    省赛前先练着，回来补完巴什博弈：一堆n个物品两个人来拿，每人至少拿一个，最多拿m个，问最后取完的人win判断条件：n%(m+1)!=0cin>>n>>m;if(n%(m+1)!=0)cout>a>>b;if(a>b)swap(a,b);inttemp=(b-a
  • C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储 Happy鱿鱼 算法c语言数据结构
    在迪杰斯特拉中，相比普利姆算法，是从顶点出发的一条路径不断的寻找最短路径，在实现的时候需要创建三个辅助数组，记录算法的关键操作，分别是Visited[MAXVEX]记录顶点是否被访问，教材上写的final数组但作用是一样的，然后第二个数组是TmpDistance[MAXVEX]，教材使用的D数组，命名语义化较弱不太好理解，实际用途与TmpDistance一样的，用于记录算法过程中，当前顶点到达邻接
  • bfs 求解迷宫最短路径问题 蒟蒻彧彧 搜索
    问题描述下图给出了一个迷宫的平面图，其中标记为1的为障碍，标记为0的为可以通行的地方。010000000100001001110000迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这个它的上、下、左、右四个方向之一。对于上面的迷宫，从入口开始，可以按DRRURRDDDR的顺序通过迷宫，一共10步。其中D、U、L、R分别表示向下、向上、向左、向右走。对于下面这个更复杂的迷宫（30行5
  • BFS迷宫最小路径问题 colorful_stars C/C++算法c++算法leetcode数据结构
    给定一个迷宫，0表示空地可以走，1表示墙壁不能穿越；在迷宫中可以向（上下左右）四个方向行进；找到从左上角到右下角的最短路径，并计算最短路径的长度。迷宫示例如下：算法步骤：1、从起始点出发，遍历四个方向，如果某个方向可以走，则先存储起来；2、按照四个方向中可以走网格进行尝试，如果该网格的四个方向仍可以走，则存储起来。3、直至到达网格的右下角，停止搜索。从以上分析可以看出，该步骤是按照一个广度优先搜索
  • Floyd算法求最短路径 阿轩不熬夜~~ 算法学习c++数据结构
    目录一.Floyd算法介绍二.算法实现一.邻接矩阵介绍二.过程简述三.Floyd核心代码三.例题分析一.B3647【模板】Floyd.二.P2835刻录光盘四.Floyd算法的优缺点一.Floyd算法介绍Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教
  • 图论中虚拟原点和反向建图两种方法—Acwing1137选择最短路线 kkj2004 算法图论
    虚拟原点和反向建图两种方法（本题中受范围限制运行速度区别不大）（附AC代码）这是蒟蒻在Acwing的第一篇题解（斗胆求赞）题目传送门现在时间是2023/1/2620:56，给大家拜个晚年看到题的第一眼就发现了这道题是一道图论中巧妙建图的模板题水题（好在范围也不大，不用加任何的优化）这道题如果一开始的思路是让某个图论算法跑W遍的话，那大概率会TLE（当然我没试），所以我们不能将这道题的时间复杂度*W
  • POJ 1062 : 昂贵的聘礼 - 最短路Dijkstra+枚举（难） bookybooky 图论最短路Dijsktrapojzoj图论
    dijkstra处理权值非负情形，最近才开始看最短路。题目大意：（中文题容易理解）大致就是说，最终要得到酋长的许诺，每件物品可能有其他物品（1件）能让此物品价格优惠，你可通过交易获得物品从而以最少金钱达到酋长许诺。交易受到“等级限制”。其中的等级限制处理需要一定的技巧，细节一定要处理好！输入：（单Case输入）第一行两个整数M，N（1>30)-1足够，邻接矩阵用int也足够，并不像DISCUSS中
  • 【代码随想录训练营第42期 Day53打卡 - 图论Part4 - 卡码网 110. 字符串接龙 105. 有向图的完全可达性 逝去的秋风 代码随想录打卡图论深度优先算法广度优先
    目录一、个人感受二、题目与题解题目一：卡码网110.字符串接龙题目链接题解：BFS+哈希题目二：卡码网105.有向图的完全可达性题目链接题解：DFS三、小结一、个人感受对于两大基本搜索：深度优先搜索DFS遍历所有路径，每条路径都是一条路走到底，用于解决需要处理所有位置的情况；广度优先搜索BFS遍历最近相邻路径（常用邻接图，邻接表实现），用于用于求得最短路径，最小次数等。今天打卡题目个人感觉挺难，事
  • 最短路算法一 halcyonfreed 算法
    2024061819:33朴素版Dijkstra47:00Heap优化版1:04:00Bellman-ford最短路算法——5种！！！考察重点：不会考算法证明，这里不讲了，重点是实现+抽象1.如何建图——如何定义点边，抽象成一个图问题Prim/i/，kruskal是最小生成树算法不是prime/ai/质数1.是么时候用？方法n图的node数m边数单源：只有一个起点，求从1个点到其他所有点/第n号点
  • 单源最短路径 洛谷【P4779】 data_structure_wr 算法
    题目描述给定一个nn个点，mm条有向边的带非负权图，请你计算从ss出发，到每个点的距离。数据保证你能从ss出发到任意点。输入格式第一行为三个正整数n,m,sn,m,s。第二行起mm行，每行三个非负整数ui,vi,wiui,vi,wi，表示从uiui到vivi有一条权值为wiwi的有向边。输出格式输出一行nn个空格分隔的非负整数，表示ss到每个点的距离。输入输出样例输入#14611222322411
  • OSPF动态路由协议 抽象文学带师 网络oracletcp/ip
    OSPF动态路由协议一．OSPF：开放式最短路径优先协议无类别链路状态型IGP协议组播更新：224.0.0.5/6支持等开销负载均衡生成的路由条目优先级10，使用cost值作为度量；链路状态型协议最大的问题，在于邻居间传递拓扑信息，更新量巨大，故非常消耗设备的带宽和计算资源，不能在中大型网络生存；因此OSPF协议需要结构化的部署--区域划分、合理ip地址规划支持触发更新；每30min进行一次周期更
  • 最短路径算法——A*算法 有一点点想CoCo你 算法
    A*算法是静态路网中求解最短路径最有效的直接搜索算法，也是解决许多搜索问题的有效算法，广泛应用于机器人路径搜索、游戏动画路径搜索等。它是图搜索算法的一种。A*算法是一种启发式的搜索算法，它是基于深度优先算法(DepthFirstSearch,DFS)和广度优先算法(BreadthFirstSearch,BFS)的一种融合算法，按照一定原则确定如何选取下一个结点。参考：A*寻路算法详解#A星#启发式
  • 数据结构——最短路径问题 胡牧之. 学习笔记数据结构数据结构
    文章目录前言一、问题分类二、单源最短路径1.无权图（BFS）（1）问题分析（2）路径记录2.有权图（朴素DiskStra算法）（1）问题分析（2）算法介绍（3）代码实现（4）思考三、多源最短路径1.问题分析2.枚举（1）思路3.Floyd算法（1）思路分析（2）代码实现前言两个顶点之间的最短路径问题就是求一条路径可以令两顶点沿途各边权值之和最小。一、问题分类对于这个问题，可以分为两种情况：1.单源
  • 数据结构总结之最短路径 @阿奇@ 最短路径图论
    1.弗洛伊德算法模板题：uva10000#include#includeusingnamespacestd;intdis[105][105];intmain(){intn;intt=0;while(cin>>n,n){inta,b,s;memset(dis,-1,sizeof(dis));cin>>s;while(cin>>a>>b,a)dis[a][b]=1;inti,j;for(intk=1;
  • 数据结构之最短路径Dijkdtra算法 HPU_FRDHR 数据结构篇最短路径Dijkdtra算法
    题意：两个整数：T和N.接下来T行，每行描述以三个以空格分隔的整数的轨迹。前两个分别代表两个点，第三个为两点间的距离输出：从N到1必须经过的最小距离优先队列优化的djk求单源最短路,链式前向星存图时间复杂度o(E*log(V))#include#include#includeusingnamespacestd; typedefpairpii; //first存储权值，second存储终点 cons
  • FFmpeg 7.0 版本 “Dijkstra”的特点概述 Codec Conductor FFmpegffmpegFFmpeg音视频
    FFmpeg7.0FFmpeg官网：https://ffmpeg.org/FFmpeg官网更新日志，2024.4.5号发布代号"Dijkstra"的7.0版本的FFmpeg，如下截图：为什么叫Dijkstra“Dijkstra”指的是艾兹格·戴克斯特拉（EdsgerWybeDijkstra），他是一位荷兰计算机科学家，对计算机科学领域做出了巨大贡献。戴克斯特拉最著名的成就之一是发明了最短路径算法，
  • 动态规划算法： 我不会JAVA！ 算法动态规划
    动态规划算法简介动态规划（DynamicProgramming,DP）是一种将复杂问题分解为更简单的子问题来求解的算法思想。它通过保存中间子问题的解，避免了重复计算，从而大大提高了解决问题的效率。动态规划通常用于求解最优化问题，比如最短路径、最大收益等。动态规划解题步骤确定状态：明确在问题的某一步中，需要存储什么信息来描述子问题的解。状态转移方程：找出如何通过前一步的状态来得到当前状态，即如何递推
  • Python高效实现Dijkstra算法求解单源最短路径问题 清水白石008 pythonPython题库python算法网络
    Python高效实现Dijkstra算法求解单源最短路径问题在Python面试中，考官通常会关注候选人的编程能力、问题解决能力以及对Python语言特性的理解。Dijkstra算法是一种经典的图算法，用于求解单源最短路径问题。本文将详细介绍如何实现Dijkstra算法，确保代码实用性强，条理清晰，操作性强。1.引言Dijkstra算法由荷兰计算机科学家EdsgerDijkstra于1956年提出，
  • 如何选择最佳路线？ 周山至水数翠峰 算法数据结构贪心算法
    交通线路的选择日常交通线路的选择，并不是按最短路径选择的。还要参考道路的等级，道路是否拥堵，道路通行速度等多种情形。本程序列举出所有能通行的线路，并计算出行驶距离，来供用户选择。当然，也可以加入道路实时通行情况，收费情况，并依据用户的偏好，计算出最佳线路。线路如何描述？·交通线路纷繁复杂，是一种无序的网状结构。对于线路的描述，本人认为所有的交通图，都是由点互相连通组成的。每个点，如果相连的点为一个
  • 2022-01-14每日刷题打卡 你好_Ä 图论算法
    2022-01-14每日刷题打卡AcWing——y总算法课851.spfa求最短路-AcWing题库给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出impossible。数据保证不存在负权回路。输入格式第一行包含整数n和m。接下来m行每行包含三个整数x,y,z，表示存在一条从点x到点y的有向边，边长为z。输出
  • PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 javaUIPHPandroidlinux
    ╔-----------------------------------╗┆                           
  • 各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 bozch .net.net mvc
    在.net mvc5中，在执行某一操作的时候，出现了如下错误：       各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。 回想过去： 在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。  &
  • Java 对象大小的计算 e200702084 java
                              Java对象的大小 如何计算一个对象的大小呢？    
  • Mybatis Spring 171815164 mybatis
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); CustomerService userService = (CustomerService) ac.getBean("customerService"); Customer cust
  • JVM 不稳定参数 g21121 jvm
            -XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。        可以说“不稳定参数”
  • 用户自动登录网站 永夜-极光 用户
    1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 2.思路:将用户的信息保存为cookie            每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
  • centos7 安装后失去win7的引导记录 程序员是怎么炼成的 操作系统
    1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ###   在后面添加    menuentry "Windows 7 (loader) (on /dev/sda1)" { 
  • Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载 aijuans oracle
    Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
  • JavaEE开源快速开发平台G4Studio_V3.2发布了 無為子 AOPoraclemysqljavaeeG4Studio
      我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。   访问G4Studio网站 http://www.g4it.org   G4Studio_V3.2版本变更日志 功能新增 (1).新增了系统右下角滑出提示窗口功能。 (2).新增了文件资源的Zip压缩和解压缩
  • Oracle常用的单行函数应用技巧总结 百合不是茶 日期函数转换函数(核心)数字函数通用函数(核心)字符函数
    单行函数;   字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 一:字符函数: .UPPER(字符串) 将字符串转为大写 .LOWER (字符串) 将字符串转为小写 .INITCAP(字符串) 将首字母大写 .LENGTH (字符串) 字符串的长度 .REPLACE(字符串,'A','_') 将字符串字符A转换成_
  • Mockito异常测试实例 bijian1013 java单元测试mockito
    Mockito异常测试实例： package com.bijian.study; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import org.junit.Assert; import org.junit.Test; import org.mockito.
  • GA与量子恒道统计 Bill_chen JavaScript浏览器百度Google防火墙
    前一阵子，统计**网址时，Google Analytics（GA） 和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下：   为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？ 首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
  • 【Linux命令三】Top命令 bit1129 linux命令
    Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果：     top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99 Tasks: 202 total, 4 running, 198 sl
  • spring四种依赖注入方式 白糖_ spring
      平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
  • angular.injector boyitech AngularJSAngularJS API
    angular.injector   描述: 创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入.   使用方法: angular.injector(modules, [strictDi])   参数详解: Param Type Details mod
  • java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待 bylijinnan Integer
    public class PC { /** * 题目：生产者-消费者。 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。 */ private static final Integer[] val=new Integer[10]; private static
  • 使用Struts2.2.1配置 Chen.H apachespringWebxmlstruts
    Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar struts2-core-2.2.1.jar struts2-sp
  • [职业与教育]青春之歌 comsci 教育
           每个人都有自己的青春之歌............但是我要说的却不是青春...        大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的....   &nbs
  • oracle连接(join)中使用using关键字 daizj JOINoraclesqlusing
    在oracle连接(join)中使用using关键字 34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. Evaluate the following SQL statement: SELECT oi.order_id, product_id, order_date FRO
  • NIO示例 daysinsun nio
    NIO服务端代码： public class NIOServer { private Selector selector; public void startServer(int port) throws IOException { ServerSocketChannel serverChannel = ServerSocketChannel.open(
  • C语言学习homework1 dcj3sjt126com chomework
    0、 课堂练习做完 1、使用sizeof计算出你所知道的所有的类型占用的空间。 int x; sizeof(x);   sizeof(int);   # include <stdio.h> int main(void) { int x1; char x2; double x3; float x4; printf(&quo
  • select in order by , mysql排序 dcj3sjt126com mysql
    If i select like this: SELECT id FROM users WHERE id IN(3,4,8,1); This by default will select users in this order 1,3,4,8, I would like to select them in the same order that i put IN() values so:
  • 页面校验-新建项目 fanxiaolong 页面校验
    $(document).ready( function() { var flag = true; $('#changeform').submit(function() { var projectScValNull = true; var s =""; var parent_id = $("#parent_id").v
  • Ehcache（02）——ehcache.xml简介 234390216 ehcacheehcache.xml简介
    ehcache.xml简介          ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
  • junit 4.11中三个新功能 jackyrong java
    junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 import static org.junit.Assert.assertEquals; import java.util.Arrays; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runn
  • 国外程序员爱用苹果Mac电脑的10大理由 php教程分享 windowsPHPunixMicrosoftperl
    Mac 在国外很受欢迎，尤其是在 设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 1、Mac OS X 是基于 Unix 的 这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
  • 位运算、异或的实际应用 wenjinglian 位运算
    一． 位操作基础，用一张表描述位操作符的应用规则并详细解释。       二． 常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。       三． 位操作与空间压缩，针对筛素数进行空间压缩。    &n
  • weblogic部署项目出现的一些问题（持续补充中……） Everyday都不同 weblogic部署失败
    好吧，weblogic的问题确实……   问题一： org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
  • tomcat7性能调优（01） toknowme tomcat7
        Tomcat优化： 1、最大连接数最大线程等设置 <Connector port="8082" protocol="HTTP/1.1"                useBodyEncodingForURI="t
  • PO VO DAO DTO BO TO概念与区别 xp9802 javaDAO设计模式bean领域模型
    O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。 它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他