URAL 1741 Communication Fiend（最短路径）

Description

Kolya has returned from a summer camp and now he's a real communication fiend. He spends all his free time on the Web chatting with his friends via ICQ. However, lately the protocol of this service was changed once again, and Kolya's client stopped working. Now, in order to communicate with his friends again, Kolya has to upgrade his client from version 1 to version n.

Kolya has found m upgrade programs on the Web. The i-th program upgrades the client from version x_i to version y_i and its size is d_imegabytes. Each program can be installed on the corresponding version of the client only; it can't be installed on either earlier or later versions.

The first version, which is currently installed on Kolya's computer, is licensed, and many of the upgrade programs are pirate copies. If a pirate upgrade program is used, the client will always be pirated after that, whatever upgrade is used later. Some of the licensed upgrade programs can be installed on a pirate version of the client, and some of them can't. All the pirate upgrade programs can be installed on both licensed and pirate versions of the client.

Kolya is missing his friends very much, so he wants to download the necessary upgrade programs as soon as possible. Unfortunately, his Web connection is not very fast. Help Kolya determine the minimal total traffic volume necessary for upgrading the client from version 1 to version n. Kolya doesn't care if the final version n of his client is licensed or not.

Input

The first line contains space-separated integers n and m (2 ≤ n ≤ 10⁴; 1 ≤ m ≤ 10⁴).

Each of the following m lines describes one upgrade program in the form “x_i y_i d_i s_i”. Here, s_i is the type of the program: “Pirated”, “Cracked”, or “Licensed”. A cracked upgrade program is a licensed program that can be installed on a pirate version of the client, and a licensed program can't be installed on a pirate version. The numbers x_i and y_i mean that the program is installed on version x_i of the client and upgrades it to version y_i. The number d_i is the size of the program in megabytes (1 ≤ x_i < y_i ≤ n; 1 ≤ d_i ≤ 10⁶). The data in each line are separated with exactly one space.

Output

If Kolya can upgrade the client from version 1 to version n, output “Online” in the first line and the minimal necessary total incoming traffic volume in the second line.

If it is impossible to upgrade the client, output “Offline”.

题目大意：有一个软件，要从1升级到n。每个升级有一个花费，用了P之后就不能再用L，求最小花费。

思路：正解是DP？不管。我们用最短路。建双层图，对于a→b L，在第一层建一条边。对于a→b P，从第一层的a建一条边到第二层的b，再从第二层的a建一条边到第二层的b。对于a→b C，第一层建一条边，第二层建一条边。再从第一层的n建一条边到第二层的n，费用为0。那么就保证了走过了P之后不会再走L，用SPFA求个最短路圆满解决。个人认为比D好写多了。我们要把图论发扬光大O(∩_∩)O~

代码（31MS）：

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <queue>
 using namespace std;
 typedef long long LL;

 const int MAXN = ;
 const int MAXE = MAXN * ;

 int head[MAXN];
 int to[MAXE], next[MAXE], cost[MAXE];
 int n, m, st, ed, ecnt;

 void init() {
     memset(head, , sizeof(head));
     ecnt = ;
 }

 void add_edge(int u, int v, int c) {
     to[ecnt] = v; cost[ecnt] = c; next[ecnt] = head[u]; head[u] = ecnt++;
     //printf("%d->%d %d\n", u, v, c);
 }

 char s[];

 void input() {
     scanf("%d%d", &n, &m);
     int a, b, c;
     for(int i = ; i < m; ++i) {
         scanf("%d%d%d%s", &a, &b, &c, s);
         if(*s == 'P') {
             add_edge(a, b + n, c);
             add_edge(a + n, b + n, c);
         }
         if(*s == 'L') {
             add_edge(a, b, c);
         }
         if(*s == 'C') {
             add_edge(a, b, c);
             add_edge(a + n, b + n, c);
         }
     }
     add_edge(n, n + n, );
     st = , ed =  * n;
 }

 LL dis[MAXN];
 bool vis[MAXN];

 void SPFA() {
     memset(dis, , sizeof(dis));
     memset(vis, , sizeof(vis));
     queue<int> que; que.push(st);
     dis[st] = ;
     while(!que.empty()) {
         int u = que.front(); que.pop();
         vis[u] = false;
         for(int p = head[u]; p; p = next[p]) {
             int &v = to[p];
             if(dis[v] == - || dis[v] > dis[u] + cost[p]) {
                 dis[v] = dis[u] + cost[p];
                 if(!vis[v]) que.push(v);
                 vis[v] = true;
             }
         }
     }
 }

 void output() {
     if(dis[ed] == -) puts("Offline");
     else {
         puts("Online");
         cout<<dis[ed]<<endl;
     }
 }

 int main() {
     init();
     input();
     SPFA();
     output();
 }