QTREE系列题解
打了快一星期的qtree终于打完了- - （其实还有两题改不出来弃疗了QAQ）
orz神AK一星期前就虐完QTREE
避免忘记还是简单写下题解吧0 0
题意：
给出一颗带边权树
一个操作：修改边权
还有一个询问：求x到y路径上边权最大值
树链剖分模版题- -blabla
代码：
#include <cstdio>
#include <cstring>
const int N=;
struct inli{
int next,data,lon;
inli(const int a=,const int b=,const int c=):
next(a),data(b),lon(c){}
}line[N*];
struct info{
int x,y;
info(const int a=,const int b=):
x(a),y(b){}
}sline[N];
int n,t,nl,dfss,back[N],tree[N*],deep[N],num[N],hard[N],dfn[N],fl[N],fat[N],gr[N],son[N];
int st,si;
char s[];
int max(int x,int y){ return x>y ? x : y; }
void swap(int &x,int &y){ int t=x; x=y,y=t; }
void clean(){
nl=dfss=;
memset(son,,sizeof(son));
memset(hard,,sizeof(hard));
memset(tree,,sizeof(tree));
}
void makehard(int t){
num[t]=;
for (int i=son[t];i;i=line[i].next)
if (line[i].data!=fat[t]){
int ne=line[i].data;
fat[ne]=t;
deep[ne]=deep[t]+;
fl[ne]=line[i].lon;
makehard(ne);
num[t]+=num[ne];
if (num[hard[t]]<num[ne]) hard[t]=ne;
}
}
void dfs(int t,int gra){
dfn[t]=++dfss;
back[dfss]=t;
gr[t]=gra;
if (hard[t]) dfs(hard[t],gra);
for (int i=son[t];i;i=line[i].next){
int ne=line[i].data;
if (ne!=fat[t] && ne!=hard[t]) dfs(ne,ne);
}
}
void build(int l,int r,int rt){
if (l==r-){
tree[rt]=fl[back[r]];
return;
}
int mid=(l+r)/;
build(l,mid,rt*);
build(mid,r,rt*+);
tree[rt]=max(tree[rt*],tree[rt*+]);
}
int getmax(int l,int r,int rt,int x,int y){
if (x==y) return ;
if (x<=l && r<=y) return tree[rt];
int mid=(l+r)/,res=;
if (x<mid) res=max(res,getmax(l,mid,rt*,x,y));
if (mid<y) res=max(res,getmax(mid,r,rt*+,x,y));
return res;
}
int getans(int x,int y){
if (x==y) return ;
if (gr[x]==gr[y]){
if (deep[x]>deep[y]) swap(x,y);
return getmax(,n,,dfn[x],dfn[y]);
}
if (deep[gr[x]]<deep[gr[y]]) swap(x,y);
return max(getans(fat[gr[x]],y),max(getmax(,n,,dfn[gr[x]],dfn[x]),fl[gr[x]]));
}
void change2(int l,int r,int rt,int x,int y){
if (l+==r) return (void)(tree[rt]=y);
int mid=(l+r)/;
if (x<mid) change2(l,mid,rt*,x,y);
else change2(mid,r,rt*+,x,y);
tree[rt]=max(tree[rt*],tree[rt*+]);
}
void change(int t,int s){
int x=sline[t].x,y=sline[t].y;
if (deep[x]>deep[y]) swap(x,y);
if (gr[x]==gr[y]) change2(,n,,dfn[x],s);
else fl[y]=s;
}
int main(){
freopen("spoj375.in","r",stdin);
freopen("spoj375.out","w",stdout);
for (scanf("%d",&t);t;t--){
clean();
scanf("%d\n",&n);
int x,y,z;
for (int i=;i<n;i++){
scanf("%d%d%d\n",&x,&y,&z);
line[++nl]=inli(son[x],y,z),son[x]=nl;
line[++nl]=inli(son[y],x,z),son[y]=nl;
sline[i]=info(x,y);
}
makehard();
dfs(,);
build(,n,);
int i=;
while (){
si=++i;
st=t;
if (i==)
i=;
if (t==)
t=;
if (t== && i==)
t=;
scanf("%s",s);
if (s[]=='Q'){
scanf("%d%d\n",&x,&y);
printf("%d\n",getans(x,y));
}
if (s[]=='C'){
scanf("%d%d\n",&x,&y);
change(x,y);
}
if (s[]=='D') break;
if (n==)
n=;
}
}
fclose(stdin);
fclose(stdout);
}
题意：
给出一颗带边权树 两个询问
1.求x到y路径上边权和
2.求x到y路径上的第k条边的边权
边权和还是树链剖分模版- -
求第k条边 刚想了一下貌似树剖也能做 但是我是用倍增的
代码：
#include <cstdio>
#include <cstring>
const int N=;
struct inli{
int next,data,lon;
inli(const int a=,const int b=,const int c=):
next(a),data(b),lon(c){}
}line[N*];
int t,n,nl,deep[N],son[N],fat[N][],dis[N][];
char s[];
void swap(int &x,int &y){ int t=x; x=y,y=t; }
void clean(){
nl=;
for (int i=;i<=n;i++){
son[i]=;
memset(fat[i],,sizeof(fat[i]));
}
}
void makefat(int t){
for (int i=;fat[fat[t][i-]][i-];++i){
fat[t][i]=fat[fat[t][i-]][i-];
dis[t][i]=dis[t][i-]+dis[fat[t][i-]][i-];
}
for (int i=son[t];i;i=line[i].next)
if (line[i].data!=fat[t][]){
int ne=line[i].data;
deep[ne]=deep[t]+;
fat[ne][]=t;
dis[ne][]=line[i].lon;
makefat(ne);
}
}
int getdis(int x,int y){
if (x==y) return ;
if (deep[x]!=deep[y]){
if (deep[x]<deep[y]) swap(x,y);
int i=;
for (;deep[fat[x][i]]>=deep[y] && fat[x][i];++i);
--i;
return dis[x][i]+getdis(fat[x][i],y);
}
if (fat[x][]==fat[y][]) return dis[x][]+dis[y][];
int i=;
for (;fat[x][i]!=fat[y][i] && fat[x][i];++i);
--i;
return dis[x][i]+dis[y][i]+getdis(fat[x][i],fat[y][i]);
}
int getgr(int x,int y){
if (x==y) return x;
if (deep[x]!=deep[y]){
if (deep[x]<deep[y]) swap(x,y);
int i=;
for (;deep[fat[x][i]]>=deep[y] && fat[x][i];++i);
--i;
return getgr(fat[x][i],y);
}
if (fat[x][]==fat[y][]) return fat[x][];
int i=;
for (;fat[x][i]!=fat[y][i] && fat[x][i];++i);
--i;
return getgr(fat[x][i],fat[y][i]);
}
int getans(int t,int s){
if (s==) return t;
int i=;
for (;deep[t]-deep[fat[t][i]]+<=s && fat[t][i];++i);
--i;
return getans(fat[t][i],s-(deep[t]-deep[fat[t][i]]));
}
int main(){
freopen("spoj913.in","r",stdin);
freopen("spoj913.out","w",stdout);
for (scanf("%d",&t);t;t--){
scanf("%d\n",&n);
clean();
int x,y,z;
for (int i=;i<n;i++){
scanf("%d%d%d\n",&x,&y,&z);
line[++nl]=inli(son[x],y,z),son[x]=nl;
line[++nl]=inli(son[y],x,z),son[y]=nl;
}
makefat();
while (){
scanf("%s",s);
if (s[]=='I'){
scanf("%d%d\n",&x,&y);
printf("%d\n",getdis(x,y));
}
if (s[]=='K'){
scanf("%d%d%d\n",&x,&y,&z);
int gr=getgr(x,y);
if (deep[x]-deep[gr]+<z){
swap(x,y);
z=deep[x]+deep[y]-deep[gr]*+-z;
}
printf("%d\n",getans(x,z));
}
if (s[]=='O') break;
}
puts("");
}
fclose(stdin);
fclose(stdout);
}
题意：
给出一颗点初始全白的树
一个操作：修改点的颜色
一个询问：求1到点x的最近黑点 没有则输出-1
这题我觉得能用动态树做
询问的时候把x access到根 splay上维护深度最小的黑点
树链剖分也可以做 线段树维护最前面的黑点即可（貌似比较简单- -）
这题我貌似就yy了一下没打- -
题意：
给出一颗点初始全白的带边权树
一个操作：修改点的颜色
一个询问：求最远的两个白色点的距离
QAQ这题被spoj卡时了啊 根本调不出来- -
其实这题好像是去湖南培训的一道题的弱化版- - 我竟然没想出来orz
我的做法是点分治+3*堆
我们定义某重心的子树的重心是 该重心的重儿子 反之重父亲
维护第一个堆que1维护 该点管辖范围内的点到该点重父亲的距离最大值
第二个堆que2维护 该点的每个重儿子的que1的堆顶的最大值（如果该点为白点 要插入一个dis为0的值）
每个que2的前2大的距离和即为两白点经过该点答案
第三个堆ans3就维护所有的que2的前2大的距离和的最大值
因为我用的是priority_queue 所以不支持删除- - 于是我就每个对打了一个时间戳
一修改3个堆一个套一个全部要改 整个世界格局混乱orz 思路不清晰就很容易晕
这题我打了3天啊QAQ（最后还没调出来←_←）
这题没A就不贴代码了- -
题意：
给出一颗点初始全白的带边权树
一个操作：修改点的颜色
一个询问：求离点x最远的白点的距离
这题和上题做法差不多 枚举管辖范围包括x的重心即可
因为上一题被卡时了 - - 这题也不敢打orz
题意：
给出一颗点初始全白的树
一个操作：修改点的颜色
一个询问：求点x与多少点相连 两点相连条是这两点的路径上的点都与点x的颜色相同
这题我是用树链剖分做的
维护f[2][i]表示i点为黑色或白色时 i的子树中与i相连的点的个数
那么x点的答案就是x点的最浅相连祖先的f[col[x]]值
当修改某点的颜色时 就修改该点到最浅相连祖先的父亲的f值即可
这题也可以用动态树做
详见QTREE7- - 233为什么和神ak写的一样
代码：
#include <cstdio>
const int N=;
struct inli{
int next,data;
inli(const int a=,const int b=):
next(a),data(b){}
}line[N*];
int n,m,nl,dfss,deep[N],gr[N],hard[N],num[N],back[N],dfn[N],son[N],tree[][N*],fat[N][],coltree[N*],col[N];
void makehard(int t){
for (int i=;fat[fat[t][i-]][i-];++i) fat[t][i]=fat[fat[t][i-]][i-];
num[t]=;
for (int i=son[t];i;i=line[i].next)
if (line[i].data!=fat[t][]){
int ne=line[i].data;
fat[ne][]=t;
deep[ne]=deep[t]+;
makehard(ne);
num[t]+=num[ne];
if (num[ne]>num[hard[t]]) hard[t]=ne;
}
}
void dfs(int t,int gra){
gr[t]=gra;
dfn[t]=++dfss;
back[dfss]=t;
if (hard[t]) dfs(hard[t],gra);
for (int i=son[t];i;i=line[i].next){
int ne=line[i].data;
if (ne!=fat[t][] && ne!=hard[t]) dfs(ne,ne);
}
} void pushdown(int t){
tree[][t*]+=tree[][t];
tree[][t*+]+=tree[][t];
tree[][t]=;
tree[][t*]+=tree[][t];
tree[][t*+]+=tree[][t];
tree[][t]=;
}
void build(int l,int r,int rt){
if (l==r){
tree[][rt]=num[back[l]];
tree[][rt]=;
return;
}
int mid=(l+r)/;
build(l,mid,rt*);
build(mid+,r,rt*+);
}
int getgr(int l,int r,int rt,int x,int y,int z){
int mid=(l+r)/,res;
if (x<=l && r<=y){
if (coltree[rt]==z) return l;
if (l==r) return -;
if (coltree[rt*+]!=z) return getgr(mid+,r,rt*+,x,y,z);
res=getgr(l,mid,rt*,x,y,z);
return res==- ? mid+ : res;
}
if (y<=mid) return getgr(l,mid,rt*,x,y,z);
if (x>mid) return getgr(mid+,r,rt*+,x,y,z);
res=getgr(mid+,r,rt*+,x,y,z);
if (res==-) return -;
if (res>mid+) return res;
res=getgr(l,mid,rt*,x,y,z);
return res==- ? mid+ : res;
}
int getans(int l,int r,int rt,int x,int y){
if (l==r) return tree[y][rt];
int mid=(l+r)/;
pushdown(rt);
if (x<=mid) return getans(l,mid,rt*,x,y);
else return getans(mid+,r,rt*+,x,y);
}
void addtree(int l,int r,int rt,int x,int y,int z,int co){
if (x<=l && r<=y) return (void)(tree[co][rt]+=z);
int mid=(l+r)/;
pushdown(rt);
if (x<=mid) addtree(l,mid,rt*,x,y,z,co);
if (mid<y) addtree(mid+,r,rt*+,x,y,z,co);
}
void changecol(int l,int r,int rt,int x){
if (l==r) return (void)(coltree[rt]^=);
int mid=(l+r)/;
if (x<=mid) changecol(l,mid,rt*,x);
else changecol(mid+,r,rt*+,x);
coltree[rt]=coltree[rt*]==coltree[rt*+] ? coltree[rt*] : -;
} int getfat(int t,int co){
if (!fat[t][] || col[fat[t][]]!=co) return t;
int save=back[getgr(,n,,dfn[gr[t]],dfn[t],co)];
if (save!=gr[t] || !fat[gr[t]][] || col[fat[gr[t]][]]!=co) return save;
else return getfat(fat[gr[t]][],co);
}
void add(int co,int x,int y,int s){
if (deep[x]>deep[y]) return;
if (gr[x]==gr[y]){
addtree(,n,,dfn[x],dfn[y],s,co);
return;
}
addtree(,n,,dfn[gr[y]],dfn[y],s,co);
add(co,x,fat[gr[y]][],s);
}
void change(int t){
int p1=getans(,n,,dfn[t],col[t]),p2=getans(,n,,dfn[t],col[t]^);
/*if (fat[t][0]){
if (col[fat[t][0]]==col[t]) add(col[t]^1,fat[t][0],fat[t][0],p2);
else add(col[t],fat[t][0],fat[t][0],-p1);
}*/
int fa=getfat(t,col[t]);
if (fat[fa][]) fa=fat[fa][];
add(col[t],fa,fat[t][],-p1);
col[t]^=;
changecol(,n,,dfn[t]);
fa=getfat(t,col[t]);
if (fat[fa][]) fa=fat[fa][];
add(col[t],fa,fat[t][],p2);
}
int main(){
freopen("spoj16549.in","r",stdin);
freopen("spoj16549.out","w",stdout);
scanf("%d",&n);
for (int x,y,i=;i<n;i++){
scanf("%d%d",&x,&y);
line[++nl]=inli(son[x],y),son[x]=nl;
line[++nl]=inli(son[y],x),son[y]=nl;
}
deep[]=;
makehard();
dfs(,);
build(,n,);
scanf("%d",&m);
for (int x,y,i=;i<=m;i++){
scanf("%d%d",&x,&y);
if (i==)
i=;
if (x) change(y);
else printf("%d\n",getans(,n,,dfn[getfat(y,col[y])],col[y]));
}
fclose(stdin);
fclose(stdout);
}
题意：
给出一颗点为黑色或白色的带点权的树
两个操作：
1.修改点的颜色
2.修改点权
一个询问：
求点与x相连的点的最大点权 两点相连条是这两点的路径上的点都与点x的颜色相同
把黑点和白点建成两颗树 同色的相连点就在同一颗树上
用set维护某点的轻边子树的最大值（取每个轻边子树的最大点权存进set）
再用动态树splay维护重边上的点最大值
询问时把该点access到根 再splay求出答案即可
access的时候要注意 当修改重边时 set要删除原轻边的最大值 加上原重边的最大值
修改点权也很好处理 - -稍微想想就知道了
修改颜色 则需要从某颜色的树上cut下一个点 再在另外颜色的树上link上一个点
但是当图为菊花图时link上的点的轻边个数可能有O(n)个 在set上一个个插入 一次操作就需要O(nlogn) 显然tle
orz神ak想到一种特别好的方法
在黑数上如果某点有个儿子的颜色为黑色就保留该点 白树同理 这样每次修改在set上就只会插入或删除一个点 就能过了
代码：
#include <cstdio>
#include <set>
using namespace std;
const int N=;
struct intr{
int fat,lc,rc,t,max,root;
intr(const int a=,const int b=,const int c=,const int d=,const int e=,const int f=):
fat(a),lc(b),rc(c),t(d),max(e),root(f){}
};
struct inli{
int next,data;
inli(const int a=,const int b=):
next(a),data(b){}
}line[N*];
int n,m,nl,son[N],col[N],fat[N];
int max(int x,int y){ return x>y ? x : y; }
struct LCT{
intr tree[N];
int xx;
multiset <int> se[N];
void clean(){ tree[]=intr(); }
void maintain(int t){
tree[t].max=tree[t].t;
if (se[t].size()) tree[t].max=max(tree[t].max,*se[t].rbegin());
if (tree[t].lc) tree[t].max=max(tree[t].max,tree[tree[t].lc].max);
if (tree[t].rc) tree[t].max=max(tree[t].max,tree[tree[t].rc].max);
}
void left(int t){
int fa=tree[t].fat,r=tree[t].rc;
tree[t].rc=tree[r].lc,tree[tree[r].lc].fat=t;
tree[r].lc=t,tree[t].fat=r;
if (tree[t].root) tree[t].root=,tree[r].root=;
else if (tree[fa].lc==t) tree[fa].lc=r;
else tree[fa].rc=r;
tree[r].fat=fa;
clean();
maintain(t);
maintain(r);
}
void right(int t){
int fa=tree[t].fat,l=tree[t].lc;
tree[t].lc=tree[l].rc,tree[tree[l].rc].fat=t;
tree[l].rc=t,tree[t].fat=l;
if (tree[t].root) tree[t].root=,tree[l].root=;
else if (tree[fa].lc==t) tree[fa].lc=l;
else tree[fa].rc=l;
tree[l].fat=fa;
clean();
maintain(t);
maintain(l);
}
void splay(int t){
while (!tree[t].root){
int fa=tree[t].fat,gr=tree[fa].fat;
if (tree[fa].root){
if (tree[fa].lc==t) right(fa);
else left(fa);
}else if (tree[gr].lc==fa){
if (tree[fa].lc==t) right(gr),right(fa);
else left(fa),right(gr);
}else if (tree[fa].rc==t) left(gr),left(fa);
else right(fa),left(gr);
}
} void access(int t){
xx=;
for (int x=,y=t;y;x=y,y=tree[y].fat){
//Wa: no(x=y) y=fat[y];
splay(y);
if (x) se[y].erase(tree[x].max);
if (tree[y].rc) se[y].insert(tree[tree[y].rc].max);
tree[x].root=;
tree[tree[y].rc].root=;
// no (tree[tree[y].rc].root=1;)
tree[y].rc=x;
clean();
maintain(y);
}
}
int getl(int t){
while (tree[t].lc) t=tree[t].lc;
return t;
}
int getans(int t){
access(t);
splay(t);
int root=getl(t);
splay(root);
return col[root]==col[t] ? tree[root].max : tree[tree[root].rc].max;
// wa:tree[t].max
}
void changenum(int t,int s){
access(t);
splay(t);
tree[t].t=s;
maintain(t);
}
void cut(int t){
access(t);
splay(t);
tree[tree[t].lc].fat=;
tree[tree[t].lc].root=;
tree[t].lc=;
maintain(t);
}
void link(int x,int y){
splay(x);
access(y);
splay(y);
tree[x].fat=y;
se[y].insert(tree[x].max);
maintain(y);
}
}lct[];
void dfs(int t){
if (fat[t]) lct[col[t]].tree[t].fat=fat[t];
for (int i=son[t];i;i=line[i].next)
if (line[i].data!=fat[t]){
int ne=line[i].data;
fat[ne]=t;
dfs(ne);
lct[col[ne]].se[t].insert(lct[col[ne]].tree[ne].max);
}
lct[].maintain(t);
lct[].maintain(t);
}
void changecol(int t){
if (fat[t]){
lct[col[t]].cut(t);
lct[col[t]^].link(t,fat[t]);
}
col[t]^=;
}
int main(){
freopen("spoj16580.in","r",stdin);
freopen("spoj16580.out","w",stdout);
scanf("%d",&n);
for (int x,y,i=;i<n;i++){
scanf("%d%d",&x,&y);
line[++nl]=inli(son[x],y),son[x]=nl;
line[++nl]=inli(son[y],x),son[y]=nl;
}
for (int i=;i<=n;i++) scanf("%d",&col[i]);
for (int x,i=;i<=n;i++){
scanf("%d",&x);
lct[].tree[i].t=lct[].tree[i].max=x;
lct[].tree[i].t=lct[].tree[i].max=x;
}
dfs();
scanf("%d",&m);
for (int x,y,z,i=;i<=m;i++){
scanf("%d%d",&x,&y);
if (i==)
i=;
if (x==) printf("%d\n",lct[col[y]].getans(y));
if (x==) changecol(y);
if (x==){
scanf("%d",&z);
lct[].changenum(y,z);
lct[].changenum(y,z);
}
}
fclose(stdin);
fclose(stdout);
}
QTREE系列题解的更多相关文章
- IEEE Bigger系列题解
Bigger系列题解 Bigger Python 坑点在于要高精度以及表达式求值,用java写可以很容易避免高精度问题 然后这道题就可以AC了 代码 import java.io.*; import ...
- QTREE系列题目总结
$QTREE$ 就是一套树上数据结构练习题. 这套题貌似来源于 $SPOJ$,我是在 $luogu$ 看到的. $QTREE1$ 题意 一棵 $n$ 个点的带边权树,要求支持 单边改权值 和 询问路径 ...
- 激！QTREE系列
我现在才开始刷 QTREE 是不是太弱了?算了不管他…… QTREE: 树链剖分裸题(据说 lct 会超时……该说是真不愧有 spoj 的气息吗?) #include <cstdio> # ...
- SPOJ QTREE 系列解题报告
题目一 : SPOJ 375 Query On a Tree http://www.spoj.com/problems/QTREE/ 给一个树,求a,b路径上最大边权,或者修改a,b边权为t. #in ...
- 【题解】NOI 系列题解总集
每次做一道 NOI 系列的估计都很激动吧,对于我这种萌新来说( P1731 [NOI1999]生日蛋糕 练习剪枝技巧,关于剪枝,欢迎看我的垃圾无意义笔记 这道题是有一定难度的,需要运用各种高科技剪枝( ...
- SPOJ Qtree系列 5/7
Qtree1 树剖裸题 注意把边权移到深度较深的点上,树剖跳的时候不要将LCA的答案统计上就行了 #include<stdio.h> #include<string.h> #d ...
- SPOJ Qtree系列
Qtree1 将边权变为这条边连接的两个点中深度更深的点的点权,这样就可以变为带修改链上最大点权.直接树链剖分即可. 下面是一份C语言代码 #include<stdio.h> #inclu ...
- SPOJ_QTREE系列题解
QTREE4 #pragma comment(linker, "/STACK:102400000,102400000") //#include<bits/stdc++.h&g ...
- GSS 系列题解
GSS GSS1 随便猫树或者线段树,就可以过了 猫树不说,线段树可以维护左边最大,右边最大,区间最大,区间值然后就做出来了. //Isaunoya #pragma GCC optimize(2) # ...
随机推荐
- NSPoint
#import <Foundation/Foundation.h> int main(int argc, const char * argv[]) { @autoreleasep ...
- Nginx+Tomcat+Memcached负载均衡集群服务搭建
操作系统:CentOS6.5 本文档主要讲解,如何在CentOS6.5下搭建Nginx+Tomcat+Memcached负载均衡集群服务器,Nginx负责负载均衡,Tomcat负责实际服务,Memc ...
- Android权限安全(3)权限的分级和自定义权限
Android的不同权限分级 Normal 一般apk都可以用, Dangerous 一般apk都可以用,但有提示 SignatureOrSystem 特定的private key签名的或系统的apk ...
- Hbase总结（一）-hbase命令,hbase安装,与Hive的区别,与传统数据库的区别,Hbase数据模型
Hbase总结(一)-hbase命令 下面我们看看HBase Shell的一些基本操作命令,我列出了几个常用的HBase Shell命令,如下: 名称 命令表达式 创建表 create '表名称', ...
- 使用stringstream时的清空操作
在C++中可以使用stringstream来很方便的进行类型转换,字符串串接,不过注意重复使用同一个stringstream对象时要先继续清空,而清空很容易想到是clear方法,而在stringstr ...
- ImageView的属性android:scaleType，即ImageView.setScaleType(ImageView.ScaleType)
1 imageView.setScaleType(ImageView.ScaleType.FIT_XY ); 1 这里我们重点理解ImageView的属性android:scaleType,即Imag ...
- 如何使java中double类型不以科学计数法表示
在java中,把一个double或者BigDecimal的小数转换为字符串时,经常会用科学计数法表示,而我们一般不想使用科学计数法,可以通过:DecimalFormat a = new Decimal ...
- createElement 创建DOM元素
<html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="C ...
- UVA 11374 Airport Express 机场快线（单源最短路，dijkstra，变形）
题意: 给一幅图,要从s点要到e点,图中有两种无向边分别在两个集合中,第一个集合是可以无限次使用的,第二个集合中的边只能挑1条.问如何使距离最短?输出路径,用了第二个集合中的哪条边,最短距离. 思路: ...
- VirtualBox的工作原理&参考网上文章
事先申明,我这里有好多东西都是看网上的,文末给出参考博客链接. 1.在设置里面为什么要选择桥接网络?baidu之后,了解到是虚拟机工作原理的不同,也就是说有好几种工作模式. bridged(桥接模式) ...