免费在线国产精品,亚洲欧美综合另类中字,国内精品在线视频

Telecowmunication （USACO）

  1 import java.io.*;
  2 import java.util.*;
  3 /*
  4 ID:
  5 LANG: JAVA
  6 TASK:telecow
  7 */
  8 public class telecow {
  9
10     public static final int WHITE = 0, GRAY = 1, BLACK = 2;
11     private int[][] flow, capacity, res_capacity;
12     private int[] parent, color, queue;
13     private int[] min_capacity;
14     private int size, source, sink, first, last;
15     private static int MAXN = 200;
16     int N,M;
17
18     private int maxFlow()  // Edmonds-Karp algorithm with O(V3E) complexity
19     {
20         flow = new int[MAXN][MAXN];
21         res_capacity = new int[MAXN][MAXN];
22         parent = new int[MAXN];
23         min_capacity = new int[MAXN];
24         color = new int[MAXN];
25         queue = new int[MAXN];
26         int max_flow = 0;
27         for (int i = 0; i < size; i++)
28             for (int j = 0; j < size; j++)
29                 res_capacity[i][j] = capacity[i][j];
30
31         while (BFS(source))
32         {
33             max_flow += min_capacity[sink];
34             int v = sink, u;
35             while (v != source)
36             {
37                 u = parent[v];
38                 flow[u][v] += min_capacity[sink];
39                 flow[v][u] -= min_capacity[sink];
40                 res_capacity[u][v] -= min_capacity[sink];
41                 res_capacity[v][u] += min_capacity[sink];
42                 v = u;
43             }
44         }
45         return max_flow;
46     }
47
48     private boolean BFS(int source)  // Breadth First Search in O(V2)
49     {
50         for (int i = 0; i < size; i++) {
51             color[i] = WHITE;
52             min_capacity[i] = Integer.MAX_VALUE;
53         }
54
55         first = last = 0;
56         queue[last++] = source;
57         color[source] = GRAY;
58
59         while (first != last)  // While "queue" not empty..
60         {
61             int v = queue[first++];
62             for (int u = 0; u < size; u++)
63                 if (color[u] == WHITE && res_capacity[v][u] > 0)
64                 {
65                     min_capacity[u] = Math.min(min_capacity[v], res_capacity[v][u]);
66                     parent[u] = v;
67                     color[u] = GRAY;
68                     if (u == sink) return true;
69                     queue[last++] = u;
70                 }
71         }
72         return false;
73     }
74
75     public void done() throws IOException {
76         BufferedReader f = new BufferedReader(new FileReader("telecow.in"));
77         PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("telecow.out")));
78         StringTokenizer st = new StringTokenizer(f.readLine());
79         N = Integer.parseInt(st.nextToken());
80         M = Integer.parseInt(st.nextToken());
81         source = Integer.parseInt(st.nextToken());
82         sink = Integer.parseInt(st.nextToken());
83         source--;
84         sink--;
85         int osource = source;
86         int osink = sink;
87         capacity = new int[N * 2][N * 2];
88
89         //init
90         for (int i = 0; i < N; i++)
91             capacity[i * 2][i * 2 + 1] = 1;
92
93         for (int i = 0; i < M; i++) {
94             st = new StringTokenizer(f.readLine());
95             int x = Integer.parseInt(st.nextToken());
96             int y = Integer.parseInt(st.nextToken());
97             x--;
98             y--;
99             capacity[x * 2 + 1][y * 2] = Integer.MAX_VALUE;
100             capacity[y * 2 + 1][x * 2] = Integer.MAX_VALUE;
101         }
102
103         for (int i = 0; i < 2 * N; i++) {
104             capacity[i][source * 2] = 0;
105             capacity[sink * 2 + 1][i] = 0;
106         }
107
108         int[] ans = new int[N + 1];
109
110         size = 2 * N;
111         source = source * 2 + 1;
112         sink = sink * 2;
113
114         int max = maxFlow();
115
116         int count = 0;
117         for (int i = 0; i < N; i++)
118             if (i != osource && i != osink) {
119                 capacity[i * 2][i * 2 + 1] = 0;
120                 int nowFlow = maxFlow();
121
122                 if (max - nowFlow == count + 1)
123                     ans[count++] = i;
124                 else
125                     capacity[i * 2][i * 2 + 1] = 1;
126             }
127
128         out.println(max);
129
130         for (int i = 0; i < count - 1; i++)
131             out.print(ans[i] + 1 + " ");
132         out.println(ans[count - 1] + 1);
133         out.close();
134
135     }
136
137     public static void main(String[] args) throws IOException {
138         telecow t = new telecow();
139         t.done();
140         System.exit(0);
141     }
142 }
143

這道題目我自己看出來是最小割的問題，而之前的題目有一道是最小割的

但是有一個不同，這道題是點的最小割，而不是常規的邊的最小割

所以這就比較麻煩，需要我們把點轉化成邊

這就讓我想起了之前的那個Fence Loops

我就是把所有的邊表示的圖轉化成了點表示的圖，我實在是不想再寫那么惡心的算法了。

然后我就去NoCow上面看了一下，果然是有很贊的方法。

具體方法就是，把一個點變成兩個點，然后在兩個點之間加一條邊，并且這條邊的權值是1

這樣的話，如果割這條邊，就相當于去掉了這個點。

剩下的事情就是跟前面的那個Pollute Control差不多了

每次去掉一條邊，然后用MaxFlow求一下最大流，如果得出的最大流==最大流-邊的權值

那么就證明這條邊是最小割。

就這樣把所有的最小割找出來，然后就可以了

貌似數據很弱，不像上次的那個Pollute那道題目，還要考慮邊的編號的問題的。

posted @ 2009-05-06 14:01 楊磊閱讀(286) | 評論 (0) | 編輯收藏

All Latin Squares (USACO)

一個搜索的題目，不過肯定是要剪枝的

最簡單的兩個剪枝我想到了

第一個：
首先，第一行已經確定了，那么我們可以把第一列也確定，就按照升序，2，3，4，5……，這樣的話，沒生成這么一個square，我們就可以隨便的去交換除了第一行后面的幾行。

他們的一個全排列就對應著一種組合，所以最后的答案乘以N-1的階乘就可以

第二個：
這個其實是看來的，就是每次只要所搜完N-1行就可以了。因為剩下的一行必然存在一個解。其實這個不難理解的，最后一行的排列順序只跟前面的每一列缺少的那個數有關。

而且也只能取缺少的那個數，所以也就是唯一的。

第三個：
要用到置換群，我沒看懂

盡管之前N次看組合數學里面都說到置換群，但是我還是似懂非懂，問了數學小王子，他也不是非常懂。然后以為這個東西沒用，就忽略了。沒想到還真的有用。

posted @ 2009-05-02 15:22 楊磊閱讀(400) | 評論 (0) | 編輯收藏

Network of Schools （USACO)

今天終于第一次寫了強連通分量的題目

雖然以前老早就知道有這么個東西，對這個東西也有概念，但是確實從來沒有寫過判別的算法

原來如此簡單，但是確實也很巧妙。

在算法導論上面看到的K算法，方法就是做兩遍DFS，因為強連通分量有一個性質，就是如果把所有的邊反向，那么它仍然是一個強連通分量。

但是今天我用的是Tarjan算法，據說效率比K算法高很多，事實上也應該是這樣，因為Tarjan算法只做了一次DFS

其實思想也很簡單，就是一直DFS（u），向下向下向下，如果突然發現有一個點可以回到u了，那么這個肯定是一個強連通分量。

哈哈，是不是很通俗。

嚴格的定義過程大家可以看這里http://www.cmykrgb123.cn/blog/scc-tarjan/

我也是參考了這個才做出來的Tarjan算法，Wiki上的那個過于龐大了，雖然封裝的非常好

說說本題，其實就是找強連通分量，然后把每個強連通分量當成一個“超點”來考慮

如果這個“超點”的入度為零，那么它就必然是一個源頭，統計這樣的“超點”的個數，就是第一問的答案。

第二問，如果有一個“超點”入度不是0，但是出度是0，那就說明這個“超點”可以給其他“超點”作貢獻。

我們就找這樣的點對，把入度是0和出度是0的點連起來。

這樣匹配過后，剩下的要么全是入度是0的，要么全是出度是0的，這些就沒辦法了，隨便從一個連通分量連接過來一條邊就可以了。

所以第二問的答案就是所有的“超點”中，入度是0和出度是0的點大的那個數。

  1 import java.io.*;
  2 import java.util.*;
  3 /*
  4 ID: yanglei4
  5 LANG: JAVA
  6 TASK:schlnet
  7 */
  8 public class schlnet {
  9     boolean[] inStack;
10     int[] DFN;
11     int[] LOW;
12     int index = 0;
13     int[] Stack;
14     int top = 0;
15     int[][] map;
16     int BelongCount = 0;
17     int[] belong;
18
19     public void Tarjan(int i) {
20         DFN[i] = LOW[i] = ++index;
21         inStack[i] = true;
22         Stack[top++] = i;
23         for (int j = 1; j <= map[i][0]; j++) {
24             if (DFN[map[i][j]] == 0) {
25                 Tarjan(map[i][j]);
26                 if (LOW[map[i][j]] < LOW[i])
27                     LOW[i] = LOW[map[i][j]];
28             }
29             else if (inStack[map[i][j]] && DFN[map[i][j]] < LOW[i])
30                 LOW[i] = DFN[map[i][j]];
31         }
32         if (DFN[i] == LOW[i]) {
33             int j = 0;
34             do {
35                 j = Stack[--top];
36                 inStack[j] = false;
37                 belong[j] = BelongCount;
38             } while (j != i);
39             BelongCount++;
40         }
41
42     }
43
44     public void done() throws IOException {
45         BufferedReader f = new BufferedReader(new FileReader("schlnet.in"));
46         PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("schlnet.out")));
47         int N = Integer.parseInt(f.readLine());
48         map = new int[N + 1][N + 1];
49         DFN = new int[N + 1];
50         LOW = new int[N + 1];
51         inStack = new boolean[N + 1];
52         Stack = new int[N + 1];
53         belong = new int[N + 1];
54
55         Arrays.fill(belong,-1);
56         for (int i = 1; i <= N; i++) {
57             StringTokenizer st = new StringTokenizer(f.readLine());
58             int len = st.countTokens();
59             map[i][0] = len - 1;
60             for (int j = 1; j <= len - 1; j++)
61                 map[i][j] = Integer.parseInt(st.nextToken());
62         }
63
64         for (int i = 1; i <= N; i++) {
65             if (DFN[i] == 0)
66                 Tarjan(i);
67         }
68         boolean[][] dis = new boolean[BelongCount + 1][BelongCount + 1];
69         for (int i = 1;i <= N;i++) {
70             for (int k = 1;k <= map[i][0];k++)
71                 dis[belong[i] + 1][belong[map[i][k]] + 1] = true;
72         }
73         int[] oud = new int[BelongCount + 1];
74         int[] ind = new int[BelongCount + 1];
75
76         for (int i = 1;i <= BelongCount;i++) {
77             for (int j = 1; j<= BelongCount;j++) {
78                 if (i!=j && dis[i][j]) {
79                     oud[i]++;
80                     ind[j]++;
81                 }
82             }
83         }
84
85         int i0 = 0;
86         int o0 = 0;
87         for (int i = 1;i <= BelongCount;i++) {
88             if (ind[i] == 0)
89                 i0++;
90             if (oud[i] == 0)
91                 o0++;
92         }
93
94         if (BelongCount == 1) {
95             out.println("1");
96             out.println("0");
97         }
98         else {
99             out.println(i0);
100             out.println(i0>o0?i0:o0);
101         }
102         out.close();
103     }
104
105     public static void main(String[] args) throws IOException {
106         schlnet t = new schlnet();
107         t.done();
108         System.exit(0);
109     }
110 }
111

posted @ 2009-04-30 20:23 楊磊閱讀(281) | 評論 (0) | 編輯收藏

Big Barn （USACO）

1 import java.io.*;
2 import java.util.*;
3
4 /*
5 ID: yanglei4
6 LANG: JAVA
7 TASK:bigbrn
8 */
9 public class bigbrn {
10     public static int min(int a, int b) {
11         if (a < b) return a;
12         else return b;
13     }
14     public static int min3(int a, int b, int c) {
15         return min(a, min(b, c));
16     }
17     public static void main(String[] args) throws IOException {
18         BufferedReader f = new BufferedReader(new FileReader("bigbrn.in"));
19         PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("bigbrn.out")));
20         StringTokenizer st = new StringTokenizer(f.readLine());
21         int N = Integer.parseInt(st.nextToken());
22         int T = Integer.parseInt(st.nextToken());
23         int[][] map = new int[N][N];
24         for (int i = 0; i < T; i++) {
25             st = new StringTokenizer(f.readLine());
26             int x = Integer.parseInt(st.nextToken());
27             int y = Integer.parseInt(st.nextToken());
28             map[x - 1][y - 1] = -1;
29         }
30
31         for (int i = 0; i < N; i++) {
32             if (map[0][i]!= -1)
33                 map[0][i] = 1;
34             if (map[i][0]!= -1)
35                 map[i][0] = 1;
36         }
37
38
39         for (int i = 1; i < N; i++)
40             for (int j = 1; j < N; j++) {
41                 if (map[i][j] != -1) {
42                     int temp = min3(map[i - 1][j], map[i][j - 1], map[i - 1][j - 1]);
43                     if (temp != -1) map[i][j] = temp + 1;
44                     else map[i][j] = 1;
45                 }
46             }
47
48         int max = 0;
49         for (int i = 0; i < N; i++)
50             for (int j = 0; j < N; j++)
51                 if (map[i][j] != 0 && map[i][j] > max)
52                     max = map[i][j];
53
54         out.println(max);
55         out.close();
56         System.exit(0);
57     }
58 }
59

應該算是一個比較基本的DP吧，狀態轉移方程也不難想，但是我最開始寫成了N^3的了

首先就是用Map[i][j]來表示以i，j為右下角的最大的square的大小

初始化就是第一行，第一列，如果不是#，那么肯定是1

然后對于i，j，我們需要觀察i - 1，j - 1，因為是square，所以只跟這個有關

如果在第i行，第j列上面，從當前位置開始，連續map[i-1][j-1]個位置，沒有#的話，那么map[i][j] = map[i-1][j-1]+1

我就是在判斷連續map[i-1][j-1]這個地方出了問題，我又加了一層循環，所以就變成了N^3的了，然后果然TLE了

這個地方完全沒必要用循環一個一個去判斷，因為其實你已經有結果了，這個結果就是map[i-1][j]和map[i][j-1]里面小的那個

map[i-1][j]肯定就是從當前位置開始，在第j列上，向上最多可以走多少步不碰到#

因為這時候實際上你已經確定了，#只有可能出現在第i行，第j列上，因為map[i-1][j-1]不是#就保證了這一點

于是，找到兩個方向上走的比較近的那個數，如果這個數是小于map[i-1][j-1]的，那么map[i][j]就等于這個數

否則，map[i][j] = map[i-1][j-1]+1

這個地方的重點就是，如果map[i-1][j-1]不是#，那么就保證了#只能在第i行，第j列上面。

只需要檢查這兩個就可以

然后我們就可以來看map[i-1][j],map[i][j-1]，這兩個東西其實跟map[i-1][j-1]共享了上面的一塊。

如果在第i行，第j列上面出現了#，那么map[i-1][j],map[i][j-1]肯定比map[i-1][j-1]小

否則，我們的square最大也就只能是map[i-1][j-1]+1，因為map[i-1][j-1]已經是以i-1,j-1為右下角最大的square了

于是狀態轉移方程就是

map[i][j] = min (map[i-1][j],map[i][j-1],map[i-1][j-1]) + 1, map[i][j] != '#'

posted @ 2009-04-30 10:40 楊磊閱讀(181) | 評論 (0) | 編輯收藏

Starry Night (USACO)

摘要: 絕對，非常考耐心，細心的一道題目，這道題目充分的說明我是考慮問題不全面的人所以現在看來TopCoder的測試數據還都算是比較弱的，真的沒有極其變態的，而且TopCoder的題目其實沒有超級復雜的，或許是因為我從來沒做過第三題吧。回正題。這道題目其實一看就知道怎么做，但是就一個字煩首先你要用FloodFill把所有的Cluster標注出來，這個不難，而且速度很快，時間... 閱讀全文

posted @ 2009-04-28 21:53 楊磊閱讀(483) | 評論 (2) | 編輯收藏

終于到了5.1了，希望能早日做完USACO

發個網絡流的標準代碼，用的是BFS

外面自己套一個類就行了

capacity自己初始化放進去就可以了

返回值在max_flow里面，有需要的話可以自己改成返回類型的

1     public static final int WHITE = 0, GRAY = 1, BLACK = 2;
2     private int[][] flow, capacity, res_capacity;
3     private int[] parent, color, queue;
4     private int[] min_capacity;
5     private int size, source, sink, first, last;
6     private int max_flow;
7
8     private void maxFlow()  // Edmonds-Karp algorithm with O(V3E) complexity
9     {
10         flow = new int[size][size];
11         res_capacity = new int[size][size];
12         parent = new int[size];
13         min_capacity = new int[size];
14         color = new int[size];
15         queue = new int[size];
16
17         for (int i = 0; i < size; i++)
18             for (int j = 0; j < size; j++)
19                 res_capacity[i][j] = capacity[i][j];
20
21         while (BFS(source))
22         {
23             max_flow += min_capacity[sink];
24             int v = sink, u;
25             while (v != source)
26             {
27                 u = parent[v];
28                 flow[u][v] += min_capacity[sink];
29                 flow[v][u] -= min_capacity[sink];
30                 res_capacity[u][v] -= min_capacity[sink];
31                 res_capacity[v][u] += min_capacity[sink];
32                 v = u;
33             }
34         }
35     }
36
37     private boolean BFS(int source)  // Breadth First Search in O(V2)
38     {
39         for (int i = 0; i < size; i++)
40         {
41             color[i] = WHITE;
42             min_capacity[i] = Integer.MAX_VALUE;
43         }
44
45         first = last = 0;
46         queue[last++] = source;
47         color[source] = GRAY;
48
49         while (first != last)  // While "queue" not empty..
50         {
51             int v = queue[first++];
52             for (int u = 0; u < size; u++)
53                 if (color[u] == WHITE && res_capacity[v][u] > 0)
54                 {
55                     min_capacity[u] = Math.min(min_capacity[v], res_capacity[v][u]);
56                     parent[u] = v;
57                     color[u] = GRAY;
58                     if (u == sink) return true;
59                     queue[last++] = u;
60                 }
61         }
62         return false;
63     }

posted @ 2009-04-28 10:39 楊磊閱讀(187) | 評論 (0) | 編輯收藏

Frame Up

原來這道題目這么簡單，記得當年高中的時候做USACO的時候，好像最后就是卡在這道題目上面，然后就是NOIP了

然后我就傷心的告別了NOIP投向了好好學習的懷抱。

今天拿過來看還是沒什么思路，然后就去搜了一下解題報告。

其實這個題目無論如何也是要DFS的，因為人家要你輸出全部的答案。這樣就不用怕了，最多就是剪剪枝。

但是最開始沒有想到這一點。

問題就在這個剪枝上，和怎么判斷合理的解上面。

方法就是，首先找到每一個Frame的四個角。

然后沿著這個Frame的每條邊走一下，如果有其他的字符，就是跟當前Frame不同的字符，那么這個字符肯定是在當前這個字符上層的。

這樣就能用一張表來確定上下關系，Above[i][j]，表示第i個字符在第j個字符上層

然后就是根據這張表來做一個DFS，這樣就可以了。

看了leokan的解題報告，說還要floyd一下。

這樣做的目的無非也就是想確定兩兩之間的上下層關系罷了。

但是似乎沒這個必要，直接DFS就可以了。

  1 import java.io.*;
  2 import java.util.*;
  3 /*
  4 ID: yanglei4
  5 LANG: JAVA
  6 TASK:frameup
  7 */
  8 public class frameup{
  9     static char[][] board;
10     static int[][] pos;
11     static int[] in;
12     static int cnt;
13     static int[][] above;
14     static char[] answer;
15     static PrintWriter out;
16     public static void findAnswer(int step) {
17         int i,j;
18         if (step >= cnt) {
19             for (int k = 0; k < cnt; k++)
20                 out.print(answer[k]);
21             out.println();
22         }
23         for (i = 0; i < 26; i++)
24         if (in[i]> 0) {
25             for (j = 0; j < 26; j++)
26             if (in[j] > 0 && above[i][j] == 1) break;
27
28               if (j >= 26) { /* no such frame, so this COULD be the next one */
29                 answer[step] = (char) ('A' + i);
30                 in[i] = 0; /* mark as in answer */
31                 findAnswer(step + 1);
32                 in[i] = 1; /* clear mark */
33               }
34
35         }
36     }
37     public static void main(String[] args) throws IOException {
38         BufferedReader f = new BufferedReader(new FileReader("frameup.in"));
39         out = new PrintWriter(new BufferedWriter(new FileWriter("frameup.out")));
40         StringTokenizer st = new StringTokenizer(f.readLine());
41         int H = Integer.parseInt(st.nextToken());
42         int W = Integer.parseInt(st.nextToken());
43
44         board = new char[30][32];
45         pos = new int[26][4];
46         in = new int[26];
47         cnt = 0;
48
49         above = new int[26][26];
50         answer = new char[27];
51
52         for (int i = 0; i < H; i++) {
53             String temp = f.readLine();
54             board[i] = temp.toCharArray();
55             for (int j = 0; j < W; j++) {
56                 if (board[i][j] != '.') {
57                     int loc = board[i][j] - 'A';
58
59                     if (in[loc] == 0) {//First time met
60                         in[loc] = 1;
61                         cnt++;
62                         pos[loc][0] = pos[loc][2] = i;
63                         pos[loc][1] = pos[loc][3] = j;
64                     }
65                     else {
66                         if (i < pos[loc][0]) pos[loc][0] = i;
67                         if (i > pos[loc][2]) pos[loc][2] = i;
68                         if (j < pos[loc][1]) pos[loc][1] = j;
69                         if (j > pos[loc][3]) pos[loc][3] = j;
70                     }
71
72                 }
73             }
74         }
75
76         for (int i = 0; i < 26; i++)
77             if (in[i] > 0) { /* for each frame */
78                  for (int j = pos[i][0]; j <= pos[i][2]; j++) { /* check left and right borders */
79
80                    /* left */
81                    int loc = board[j][pos[i][1]] - 'A';
82                    if (loc != i) /* there's a different frame where this one should be */
83                      above[loc][i] = 1; /* that different frame must be above this one */
84
85                    /* right */
86                    loc = board[j][pos[i][3]] - 'A';
87                    if (loc != i) /* same as left */
88                      above[loc][i] = 1;
89                  }
90                  for (int j = pos[i][1]; j <= pos[i][3]; j++) { /* check top and bottom */
91
92                    /* top */
93                    int loc = board[pos[i][0]][j] - 'A';
94                    if (loc != i)
95                      above[loc][i] = 1;
96
97                    /* bottom */
98                    loc = board[pos[i][2]][j] - 'A';
99                    if (loc != i)
100                      above[loc][i] = 1;
101                  }
102             }
103
104         findAnswer(0);
105         out.close();
106         System.exit(0);
107     }
108 }
109

posted @ 2009-04-27 17:07 楊磊閱讀(161) | 評論 (0) | 編輯收藏

UML讀書筆記

Principles of Modeling

First, The choice of what models to create has a profound influence on how a problem is attacked and how a solution is shaped.
Second, Every model may be expressed at different levels of precision.
Third, The best models are connected to reality.
Fourth,No single model or view is sufficient. Every nontrivial system is best approached through a small set of nearly independent models with multiple viewpoints.

Three major elements:

the UML's basic building blocks
the rules that dictate how those building blocks may be put together
some common mechanisms that apply throughout the UML

The vocabulary of the UML encompasses three kinds of building blocks:

Things
Relationships
Diagrams

Three kinds of relationships that are most important: dependencies, generalizations, and associations.

Dependencies are using relationships. For example, pipes depend on the water heater to heat the water they carry.
Associations are structural relationships among instances. For example, rooms consist of walls and other things; walls themselves may have embedded doors and windows; pipes may pass through walls.
Generalizations connect generalized classes to more-specialized ones in what is known as subclass/superclass or child/parent relationships. For example, a picture window is a kind of window with very large, fixed panes; a patio window is a kind of window with panes that open side to side.

posted @ 2009-04-26 18:37 楊磊閱讀(205) | 評論 (0) | 編輯收藏

解決Windows 7支付寶問題

先自動下載了新的控件

然后去用這個文件去注冊掉那個什么什么CAB

http://www.aygfsteel.com/Files/LittleDS/800A138F.rar

然后再去下載 xenroll.dll
去 cmd 運行 regsvr32 xenroll.dll

然后就可以了，就可以導入數字證書了。

posted @ 2009-04-25 14:16 楊磊閱讀(170) | 評論 (0) | 編輯收藏

The Primes （USACO）

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ --> 1 import java.io.*; 2 import java.util.*; &n... 閱讀全文

posted @ 2009-04-24 12:01 楊磊閱讀(214) | 評論 (0) | 編輯收藏

留言簿(1)

隨筆分類

隨筆檔案

相冊

搜索

最新評論