1791: [Ioi2008]Island 岛屿 

Time Limit: 20 Sec  Memory Limit: 162 MB

Submit: 908  Solved: 159

[Submit][

id=1791" target="_blank">Status]

Description

你将要游览一个有N个岛屿的公园。从每个岛i出发,仅仅建造一座桥。桥的长度以Li表示。公园内总共同拥有N座桥。

虽然每座桥由一个岛连到还有一个岛。但每座桥均能够双向行走。同一时候,每一对这样的岛屿。都有一艘专用的往来两岛之间的渡船。

相对于乘船而言,你更喜欢步行。

你希望所经过的桥的总长度尽可能的长,但受到下面的限制。 • 能够自行挑选一个岛開始游览。 • 不论什么一个岛都不能游览一次以上。 • 不管不论什么时间你都能够由你如今所在的岛S去还有一个你从未到过的岛D。

由S到D能够有下面方法: o 步行:仅当两个岛之间有一座桥时才有可能。对于这样的情况。桥的长度会累加到你步行的总距离;或者 o 渡船:你能够选择这样的方法,仅当没有不论什么桥和/或曾经使用过的渡船的组合能够由S走到D(当检查是否可到达时,你应该考虑全部的路径。包含经过你曾游览过的那些岛)。 注意,你不必游览全部的岛,也可能无法走全然部的桥。

任务 编写一个程序,给定N座桥以及它们的长度。依照上述的规则,计算你能够走过的桥的最大长度。

限制 2 <= N <= 1,000,000 公园内的岛屿数目。 1<= Li <= 100,000,000 桥i的长度。

Input

• 第一行包括N个整数。即公园内岛屿的数目。岛屿由1到N编号。 • 随后的N行每一行用来表示一个岛。

第i 行由两个以单空格分隔的整数,表示由岛i筑的桥。第一个整数表示桥还有一端的岛,第二个整数表示该桥的长度Li。你能够如果对於每座桥,其端点总是位于不同的岛上。

Output

你的程序必须向标准输出写出包括一个整数的单一行。就可以能的最大步行距离。 注1:对某些測试。答案可能无法放进32-bit整数。你要取得这道题的满分,可能须要用Pascal的int64或C/C++的long long类型。 注2:在比赛环境执行Pascal程序,由标准输入读入64-bit数据比32-bit数据要慢得多,即使被读取的数据能够32-bit表示。

我们建议把输入数据读入到32-bit数据类型。 评分 N不会超过4,000。

Sample Input

7

 3 8

 7 2

 4 2

 1 4

 1 9

 3 4

 2 3

Sample Output

24

/******************************************************************************/

题意:

输入n,然后n行第i行是由i向外引一条无向边,以及输入边的权值。这样会组成k个联通图,每一个图上取两点。使其间路径长度最大,求这些“最大路径”长度总和。

题目分析:

首先一个n点联通图上会有n条边,而它又联通,全部它一定是有环的,而由于有n-1条边的n点联通图保证图联通且无环,剩下一条边则一定使“树”中有且仅仅有一个环,于是得证每一个联通图都是一个“基环树”,即有且仅有一个环的树。

那么如今我们应该输出的就是全部基环树的直径总和(树的直径即树上点不反复的最长路径)。

如图,这棵基环树的直径就是11到5。经过3。长度71。

题解:

我们须要对每一个基环树单独处理,先搜到它的环,然后dfs求每一个环上点往外枝杈的最长路径,这样每一个点就有了一个权值。然后环上每一个边又有了一个权值。就能够在环上做一发单调队列动规,求基环树直径长度啦!

当然,我们对于每棵树的直径是在动规里面定论的。只是它的初值却不能在动规前赋成0!

例如以下图中。直径就不经过环。为13到6,长度79,所以在dfs求环上点权的,也不能忘了更新直径值,只是怎么更新就须要略加斟酌了。

实现:

首先双向建边,然后对随意点搜索,搜到某个点已经搜过了,就代表这个点是环上的,然后处理环。再然后就是搜索找到每一个点。然后递归出枝杈边权和最长值。作为点权值,进行单调队列优化后的动规,过程中更新直径长度。单调队列把点倍增,然后两点间长度小于环长度就可以。

我在此证明一下动规的单调性。【甚水,可略过】首先设点A、B、C、D依次排列,则从A到D(有向。不能从D到A)的长度为环上A到D的长度和加上A、D点权和。

不要问我为什么不能从D到A。由于我已经把点倍增了,从D到第二个A就是“从D到A”了。

好吧。跑题了。我来总结一下,

长度A到D = A点权+A~B边长+B~C边长+C~D边长+D点权

那么长度B到D就 = B点权+B~C边长+C~D边长+D点权

发生了什么?什么?仅仅要B点权 > A点权+A~B边长,那么从B到D就比A到D优!

同理。后面的一样。

结果出来了。然后输出就可以,注意输入要用int,输出用long long。不然会超时,超非常多,IOI2008測试数据中isl18f.in秒出解。可是用long long 读入,呵呵呵呵。

时间丶代码复杂度优化:

找环实现非常烦非常磨叽对不正确?这时候我们能够引入一种新的解决方法,类似于最小树形图找环的实现(上文的实现方法我事实上AC前并不知道)。

眼下BZOJ排名第一你怕不怕?常数再好好写写还能更快你怕不怕?就问你怕不怕?

这里就须要运用到本题的一些性质。

首先我们能够把数据输入时的边方向当成正方向,其反方向。好吧。“当成”反方向。这样每一个点都有且仅有一条出边。然后我们从随意一个点開始遍历。假设没有环。那是不是根本停不下来?!而数据又是有限的。所以最后就一定会连到已有的链上的某点,而非常好想,这个点向前遍历,最后会回到这个点上,即它是一个环,而之前的点的出边方向都是在向环推进。这时候我们再把其他点挨个遍历,首先同一个联通图是一定不会有俩环的,所以要想改变“根本停不下来”的现状。新点遍历到最后。就一定会指向某个已经遍历过的点,从而连上了环,或者方向是向环的。

这样我们能够把数据输入的方向存为next[i]。然后把长度存为len[i]。而反向边则有邻接表存储(讨厌指针的我写的是链式前向星)。

这样我们仅仅须要遍历随意点,通过next标记沿途全部点,然后遍历到一个已标记点,即能够快速找到基环树的环了。然后我们对环上每一个点进行“-1”标记,禁止接下来的dfs找到该点(反边存了环上的边),从而能够再接下来的dfs中顺利给环上每一个点赋值(找枝杈,递归求最长长度)。

优化到此结束,接下来的单调队列与一般做法无异了。

注意:

本题dfs递归出解时因为层数过深可能爆系统栈,所以须要写一份非递归版自写栈的dfs。我会在后面代码附上凝视掉的递归版dfs以利于理解思想。(不要想着开大系统栈!

那还不如手写非递归dfs呢。)

  1. /**************************************************************
  2. Problem: 1791
  3. User: 18357
  4. Language: C++
  5. Result: Accepted
  6. Time:11052 ms
  7. Memory:120100 kb
  8. ****************************************************************/
  9.  
  10. #include <cstdio>
  11. #include <cstring>
  12. #include <algorithm>
  13. #include <stack>
  14. #include <iostream>
  15. #define N 1050000
  16. using namespace std;
  17. struct Syndra
  18. {
  19. int u,v,len,next;
  20. }e[N];
  21. struct Fiona
  22. {
  23. int edge,flag1,flag2;
  24. long long temp,max1,max2;
  25. }s[N];
  26. int head[N],cnt,n;
  27. int visit[N],next[N],len[N];
  28. int i,j,k;
  29. long long sa[N],pre[N],ans;
  30. void add(int u,int v,int len)
  31. {
  32. cnt++;
  33. e[cnt].u=u;
  34. e[cnt].v=v;
  35. e[cnt].len=len;
  36. e[cnt].next=head[u];
  37. head[u]=cnt;
  38. }
  39. int que[N<<1];
  40. long long sum[N<<1],ret;
  41. long long dp(int num)
  42. {
  43. int top,tail;
  44. int u,b,star;
  45. int et;
  46. for(et=1;et<(num<<1);et++)
  47. {
  48. sum[et]=sum[et-1]+pre[(et-1)>=num?(et-1-num):(et-1)];
  49. }
  50. top=tail=0;
  51.  
  52. que[top]=0;
  53. for(et=1;et<(num<<1);et++)
  54. {
  55. while(et-que[top]>=num)top++;
  56. u=que[top];
  57. ret=max(ret,sa[et>=num?et-num:et]+sa[u>=num?
  58.  
  59. u-num:u]+sum[et]-sum[u]);
  60. b=que[tail];
  61. que[++tail]=et;
  62. for(star=tail;star>top;b=que[star-1])
  63. {
  64. if(sum[et]-sum[b]+sa[b>=num?b-num:b]<sa[et>=num?et-num:et])
  65. {
  66. que[star]=b;
  67. que[--star]=et;
  68. }
  69. else break;
  70. }
  71. tail=star;
  72. }
  73.  
  74. /*que[tail++]=0;
  75. for(et=1;et<(num<<1);++et)
  76. {
  77. while(top<tail&&et-que[top]>=num)++top;
  78. u=que[top];
  79. ret=max(ret,sa[et>=num?
  80.  
  81. et-num:et]+sa[u>=num?u-num:u]+sum[et]-sum[u]);
  82. while(top<tail&&sa[et>=num?
  83.  
  84. et-num:et]>=sa[que[tail-1]>=num?
  85.  
  86. que[tail-1]-num:que[tail-1]]+sum[et]-sum[que[tail-1]])--tail;
  87. que[tail++]=et;
  88. }*/
  89. return ret;
  90. }
  91. void build()
  92. {
  93. cnt=1;
  94. memset(head,0,sizeof(head));
  95. memset(visit,0,sizeof(visit));
  96. scanf("%d",&n);
  97. for(i=1;i<=n;i++)
  98. {
  99. scanf("%d%d",&next[i],&len[i]);
  100. add(next[i],i,len[i]);
  101. }
  102. }
  103. stack<int>sk;
  104. int fa[N];
  105. void dfs(int x)
  106. {
  107. if(s[x].edge==0)
  108. {
  109. sk.pop();
  110. if(s[x].flag2)ret=max(ret,s[x].max1+s[x].max2);
  111. if(visit[x]==-1)
  112. return ;
  113. x = sk.top();
  114. {
  115. int v,tt=s[x].edge;
  116. v=e[tt].v;
  117. visit[v]=i;
  118. s[x].temp=s[v].max1+e[tt].len;
  119. if(s[x].max1<s[x].temp)
  120. {
  121. if(s[x].flag1)s[x].max2=s[x].max1,s[x].flag2=1;
  122. else s[x].flag1=1;
  123. s[x].max1=s[x].temp;
  124. }
  125. else if(s[x].max2<s[x].temp)s[x].max2=s[x].temp,s[x].flag2=1;
  126. s[x].edge=e[tt].next;
  127. }
  128. return ;
  129. }
  130. int v,tt=s[x].edge;
  131. v=e[tt].v;
  132. if(visit[v]==-1)
  133. {
  134. s[x].edge=e[tt].next;
  135. return ;
  136. }
  137. fa[v]=x;
  138. s[v].edge=head[v];
  139. sk.push(v);
  140. }
  141. long long handle(int x)
  142. {
  143. s[x].edge=head[x];
  144. sk.push(x);
  145. while(!sk.empty())
  146. {
  147. dfs(sk.top());
  148. }
  149. return s[x].max1;
  150. }/*handle(long long)+dfs(void)=dfs(long long)*/
  151. /*long long dfs(int x)
  152. {
  153. int et,v,flag1,flag2;
  154. long long max1,max2;
  155. for(max1=max2=0,flag1=flag2=0,et=head[x];et;et=e[et].next)
  156. {
  157. v=e[et].v;
  158. if(visit[v]==-1)continue;
  159. temp=dfs(v)+e[et].len;
  160. visit[v]=i;
  161. if(max1<temp)
  162. {
  163. if(flag1)max2=max1,flag2=1;
  164. max1=temp;
  165. flag1=1;
  166. }
  167. else if(max2<temp)max2=temp,flag2=1;
  168. }
  169. if(flag2)ret=max(ret,max1+max2);
  170. return max1;
  171. }*/
  172. int main()
  173. {
  174. // freopen("isl.in","r",stdin);
  175. // freopen("isl.out","w",stdout);
  176. int u,v;
  177. build();
  178. for(i=1;i<=n;i++)
  179. {
  180. if(!visit[i])
  181. {
  182. for(u=i;!visit[u];u=next[u])
  183. {
  184. visit[u]=i;
  185. }
  186. if(visit[u]==i)
  187. {
  188. ret=0;cnt=0;
  189. visit[u]=-1;
  190. for(v=next[u];v!=u;v=next[v])
  191. {
  192. visit[v]=-1;
  193. }
  194. v=u;
  195. do{
  196. pre[cnt]=len[v];
  197. sa[cnt++]=handle(v);
  198. v=next[v];
  199. }while(v!=u);
  200. ans+=dp(cnt);
  201. }
  202. }
  203. }
  204. cout<<ans;
  205. return 0;
  206. }
  207.  
  208. 

以下是读入优化后的代码,这年头,你不读入优化,光输入就得比这代码慢啊~

  1.  
  1. /**************************************************************
  2. Problem: 1791
  3. User: 18357
  4. Language: C++
  5. Result: Accepted
  6. Time:4556 ms
  7. Memory:120132 kb
  8. ****************************************************************/
  9.  
  10. #include <cstdio>
  11. #include <cstring>
  12. #include <algorithm>
  13. #include <stack>
  14. #include <cctype>
  15. #include <iostream>
  16. #define N 1050000
  17. using namespace std;
  18. inline int getc() {
  19. static const int L = 1<<15;
  20. static char buf[L],*S=buf,*T=buf;
  21. if(S==T){
  22. T=(S=buf)+fread(buf,1,L,stdin);
  23. if(S==T)return EOF;
  24. }
  25. return *S++;
  26. }
  27. inline int getint() {
  28. int c;
  29. while(!isdigit(c = getc()));
  30. int tmp = c-'0';
  31. while(isdigit(c=getc()))
  32. tmp=(tmp<<1)+(tmp<<3)+c-'0';
  33. return tmp;
  34. }
  35. struct Syndra
  36. {
  37. int u,v,len,next;
  38. }e[N];
  39. struct Fiona
  40. {
  41. int edge,flag1,flag2;
  42. long long temp,max1,max2;
  43. }s[N];
  44. int head[N],cnt,n;
  45. int visit[N],next[N],len[N];
  46. int i,j,k;
  47. long long sa[N],pre[N],ans;
  48. void add(int u,int v,int len)
  49. {
  50. cnt++;
  51. e[cnt].u=u;
  52. e[cnt].v=v;
  53. e[cnt].len=len;
  54. e[cnt].next=head[u];
  55. head[u]=cnt;
  56. }
  57. int que[N<<1];
  58. long long sum[N<<1],ret;
  59. long long dp(int num)
  60. {
  61. int top,tail;
  62. int u,b,star;
  63. int et;
  64. for(et=1;et<(num<<1);et++)
  65. {
  66. sum[et]=sum[et-1]+pre[(et-1)>=num?(et-1-num):(et-1)];
  67. }
  68. top=tail=0;
  69. /*
  70. que[top]=0;
  71. for(et=1;et<(num<<1);et++)
  72. {
  73. while(et-que[top]>=num)top++;
  74. u=que[top];
  75. ret=max(ret,sa[et>=num?et-num:et]+sa[u>=num?
  76.  
  77. u-num:u]+sum[et]-sum[u]);
  78. b=que[tail];
  79. que[++tail]=et;
  80. for(star=tail;star>top;b=que[star-1])
  81. {
  82. if(sum[et]-sum[b]+sa[b]<sa[et])
  83. {
  84. que[star]=b;
  85. que[--star]=et;
  86. }
  87. else break;
  88. }
  89. tail=star;
  90. }
  91. */
  92. que[tail++]=0;
  93. for(et=1;et<(num<<1);++et)
  94. {
  95. while(top<tail&&et-que[top]>=num)++top;
  96. u=que[top];
  97. ret=max(ret,sa[et>=num?et-num:et]+sa[u>=num?u-num:u]+sum[et]-sum[u]);
  98. while(top<tail&&sa[et>=num?et-num:et]>=sa[que[tail-1]>=num?
  99.  
  100. que[tail-1]-num:que[tail-1]]+sum[et]-sum[que[tail-1]])--tail;
  101. que[tail++]=et;
  102. }
  103. return ret;
  104. }
  105. void build()
  106. {
  107. cnt=1;
  108. memset(head,0,sizeof(head));
  109. memset(visit,0,sizeof(visit));
  110. n=getint();
  111. for(i=1;i<=n;i++)
  112. {
  113. next[i]=getint();
  114. len[i]=getint();
  115. add(next[i],i,len[i]);
  116. }
  117. }
  118. stack<int>sk;
  119. int fa[N];
  120. void dfs(int x)
  121. {
  122. if(s[x].edge==0)
  123. {
  124. sk.pop();
  125. if(s[x].flag2)ret=max(ret,s[x].max1+s[x].max2);
  126. if(visit[x]==-1)
  127. return ;
  128. x = sk.top();
  129. {
  130. int v,tt=s[x].edge;
  131. v=e[tt].v;
  132. visit[v]=i;
  133. s[x].temp=s[v].max1+e[tt].len;
  134. if(s[x].max1<s[x].temp)
  135. {
  136. if(s[x].flag1)s[x].max2=s[x].max1,s[x].flag2=1;
  137. else s[x].flag1=1;
  138. s[x].max1=s[x].temp;
  139. }
  140. else if(s[x].max2<s[x].temp)s[x].max2=s[x].temp,s[x].flag2=1;
  141. s[x].edge=e[tt].next;
  142. }
  143. return ;
  144. }
  145. int v,tt=s[x].edge;
  146. v=e[tt].v;
  147. if(visit[v]==-1)
  148. {
  149. s[x].edge=e[tt].next;
  150. return ;
  151. }
  152. fa[v]=x;
  153. s[v].edge=head[v];
  154. sk.push(v);
  155. }
  156. long long handle(int x)
  157. {
  158. s[x].edge=head[x];
  159. sk.push(x);
  160. while(!sk.empty())
  161. {
  162. dfs(sk.top());
  163. }
  164. return s[x].max1;
  165. }/*handle(long long)+dfs(void)=dfs(long long)*/
  166. /*long long dfs(int x)
  167. {
  168. int et,v,flag1,flag2;
  169. long long max1,max2;
  170. for(max1=max2=0,flag1=flag2=0,et=head[x];et;et=e[et].next)
  171. {
  172. v=e[et].v;
  173. if(visit[v]==-1)continue;
  174. temp=dfs(v)+e[et].len;
  175. visit[v]=i;
  176. if(max1<temp)
  177. {
  178. if(flag1)max2=max1,flag2=1;
  179. max1=temp;
  180. flag1=1;
  181. }
  182. else if(max2<temp)max2=temp,flag2=1;
  183. }
  184. if(flag2)ret=max(ret,max1+max2);
  185. return max1;
  186. }*/
  187. int main()
  188. {
  189. int u,v;
  190. build();
  191. for(i=1;i<=n;i++)
  192. {
  193. if(!visit[i])
  194. {
  195. for(u=i;!visit[u];u=next[u])
  196. {
  197. visit[u]=i;
  198. }
  199. if(visit[u]==i)
  200. {
  201. ret=0;cnt=0;
  202. visit[u]=-1;
  203. for(v=next[u];v!=u;v=next[v])
  204. {
  205. visit[v]=-1;
  206. }
  207. v=u;
  208. do{
  209. pre[cnt]=len[v];
  210. sa[cnt++]=handle(v);
  211. v=next[v];
  212. }while(v!=u);
  213. ans+=dp(cnt);
  214. }
  215. }
  216. }
  217. cout<<ans;
  218. return 0;
  219. }

版权声明:本文博主原创文章。博客,未经同意不得转载。

【BZOJ1791】【IOI2008】【基环树】island(status第一速度)的更多相关文章

  1. [bzoj1791][ioi2008]Island 岛屿(基环树、树的直径)

    [bzoj1791][ioi2008]Island 岛屿(基环树.树的直径) bzoj luogu 题意可能会很绕 一句话:基环树的直径. 求直径: 对于环上每一个点记录其向它的子树最长路径为$dp_ ...

  2. bzoj1791[IOI2008]Island岛屿(基环树+DP)

    题目链接:https://www.lydsy.com/JudgeOnline/problem.php?id=1791 题目大意:给你一棵n条边的基环树森林,要你求出所有基环树/树的直径之和.n< ...

  3. BZOJ1791 [Ioi2008]Island 岛屿[基环树+单调队列优化DP]

    基环树直径裸题. 首先基环树直径只可能有两种形式:每棵基环树中的环上挂着的树的直径,或者是挂在环上的两个树的最大深度根之间的距离之和. 所以,先对每个连通块跑一遍,把环上的点找出来,然后对环上每个点跑 ...

  4. P4381 [IOI2008]Island(基环树+单调队列优化dp)

    P4381 [IOI2008]Island 题意:求图中所有基环树的直径和 我们对每棵基环树分别计算答案. 首先我们先bfs找环(dfs易爆栈) 蓝后我们处理直径 直径不在环上,就在环上某点的子树上 ...

  5. [IOI2008/BZOJ1791 岛屿](处理基环树的小技巧&基于bfs树形DP)

    IOI2008/BZOJ1791 岛屿 题目大意是在一个基环树森林里求每一棵基环树的直径①的和. 其实就是树的直径的基环树升级版.我们先把环找出来,然后从环上的每一个节点x出发,并且不经过环上其他节点 ...

  6. BZOJ1791[Ioi2008]Island 岛屿 ——基环森林直径和+单调队列优化DP+树形DP

    题目描述 你将要游览一个有N个岛屿的公园.从每一个岛i出发,只建造一座桥.桥的长度以Li表示.公园内总共有N座桥.尽管每座桥由一个岛连到另一个岛,但每座桥均可以双向行走.同时,每一对这样的岛屿,都有一 ...

  7. BZOJ 1791: [IOI2008]Island 岛屿 - 基环树

    传送门 题解 题意 = 找出无向基环树森林的每颗基环树的直径. 我们首先需要找到每颗基环树的环, 但是因为是无向图,用tarjan找环, 加个手工栈, 我也是看了dalao的博客才知道tarjan找无 ...

  8. bzoj 1791: [Ioi2008]Island 岛屿【基环树+单调队列优化dp】

    我太菜了居然调了一上午-- 这个题就是要求基环树森林的基环树直径和 大概步骤就是找环->dp找每个环点最远能到达距离作为点权->复制一倍环,单调队列dp 找环是可以拓扑的,但是利用性质有更 ...

  9. luogu 4381 [IOI2008]Island 单调队列 + 基环树直径 + tarjan

    Description 你将要游览一个有N个岛屿的公园.从每一个岛i出发,只建造一座桥.桥的长度以Li表示.公园内总共有N座桥.尽管每座桥由一个岛连到另一个岛,但每座桥均可以双向行走.同时,每一对这样 ...

随机推荐

  1. 【cocos2d-x不要在生产白片步骤】第二项:制作Block分类

    由于游戏非常多使用阻断,因此,我们创建了一个单独的类中Block. 于Blcok.h声明了两个初始化函数: static Block* createWithArgs(Color3B color, Si ...

  2. javascript它【蛇系列】第一弹:简单的蛇实现

    参考博客:http://blog.csdn.net/sunxing007/article/details/4187038 上面的博客是一个参考,竟第一次做.真让自己盲人摸象做不出来. 只是我在其上做了 ...

  3. Python的Tkinter去除边框

    from Tkinter import * class Application(Frame): def __init__(self,master=None, *args, **kwargs): Fra ...

  4. 6 款好用的 PC+Android 同步 GTD 软件

    6 款好用的 PC+Android 同步 GTD 软件 最近老鼠工作积极性比较高(其实只要是买平板电脑的欲望在鼓舞着干劲),所以每天很多任务安排,为了不混乱,免不了要用 GTD(Go to do)软件 ...

  5. poj2486(树形dp)

    题目链接:http://poj.org/problem?id=2486 题意:一颗树,n个点(1-n),n-1条边,每个点上有一个权值,求从1出发,走m步,最多能遍历到的权值. 分析:非常不错的树形d ...

  6. 实战:sqlserver 2008 扩展事件-XML转换为标准的table格式

    --假设已经存在Event Session删除 IF EXISTS (SELECT * FROM sys.server_event_sessions WHERE name='MonitorLongQu ...

  7. 通过Java字节码发现有趣的内幕之String篇(上)(转)

    原文出处: jaffa 很多时候我们在编写Java代码时,判断和猜测代码问题时主要是通过运行结果来得到答案,本博文主要是想通过Java字节码的方式来进一步求证我们已知的东西.这里没有对Java字节码知 ...

  8. uva 11722 - Joining with Friend(概率)

    题目连接:uva 11722 - Joining with Friend 题目大意:你和朋友乘火车,而且都会路过A市.给定两人可能到达A市的时段,火车会停w.问说两人能够见面的概率. 解题思路:y = ...

  9. JavaWeb学习总结(一)JavaWeb开发入门

    静态网页和动态网页 静态网页:在服务器上没有经过服务器解释执行的网页. 动态网页:在服务器上经过服务器解释执行的网页. 无论是静态网页还是动态网页,客户端看到的网页都是由HTML所构成的,所以Java ...

  10. 用java读写properties文件的代码

    package com.LY; import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.F ...