C++博客-重剑无锋

chrome最新版编译方法

Gin — Fri, 06 Mar 2015 09:06:00 GMT

主要步骤:
注:除了pan.baidu.com,其他都在墙外

高手可以看这个,里面有详细的步骤和注意事项:

http://www.chromium.org/developers/how-tos/build-instructions-windows

正规步骤:
#.下载depot_tools : https://src.chromium.org/svn/trunk/tools/depot_tools.zip
#.解压,例如:c:\depot_tools
#.设置环境变量,例如 C:\depot_tools(放到PATH最前面,有人安装了python,我们用depot_tools的python)
#.[全局墙外状态][cmd下]执行gclient(保证gclient命令在cmd下存在,不存在则注销重启)

#.[全局墙外状态]找一个空目录例如d:\chromium(空间足够大,最少30G),执行fetch chromium,下载很久

#.[cmd下][刚才的目录,例如d:\chromium]set DEPOT_TOOLS_WIN_TOOLCHAIN=0

#.[全局墙外状态][cmd下][刚才的目录,例如d:\chromium]gclient runhooks

#.vs2013 + directX SDK + win8.1 SDK

#.[cmd下][刚才的目录,例如d:\chromium]cd src

#.操作系统locale改为English

#.[cmd下][刚才的目录的src下,例如d:\chromium\src]ninja -C out\Debug chrome

下载很慢,代码很大,我这里共享了代码和depot_tools

链接：http://pan.baidu.com/s/1kT00Vhd 密码：75c0

使用我共享的文件的步骤:

#.下载depot_tools : 共享里有
#.解压,例如:c:\depot_tools
#.设置环境变量,例如 C:\depot_tools(放到PATH最前面,有人安装了python,我们用depot_tools的python)
#.[全局墙外状态][cmd下]执行gclient(保证gclient命令在cmd下存在,不存在则注销重启)

#.找一个空目录例如d:\chromium,

#.[cmd下][刚才的目录,例如d:\chromium]mkdir src

#.[cmd下][刚才的目录的src下,例如d:\chromium\src]把共享中的12G的代码解压到这里

#.[刚才的目录,例如d:\chromium]把.gclient .gclient_entries放到这个文件夹中

#.[cmd下][刚才的目录,例如d:\chromium]set DEPOT_TOOLS_WIN_TOOLCHAIN=0

#.[全局墙外状态][cmd下][刚才的目录,例如d:\chromium]执行gclient runhooks

#.vs2013 + directX SDK + win8.1 SDK
#.操作系统locale改为English

#.[cmd下][刚才的目录,例如d:\chromium]cd src

#.[cmd下][刚才的目录的src下,例如d:\chromium\src]ninja -C out\Debug chrome

Gin 2015-03-06 17:06 发表评论

blog换个地方

Gin — Sun, 23 Dec 2012 07:55:00 GMT

www.cnblogs.com/gggin
原因是因为这个太卡了。。

Gin 2012-12-23 15:55 发表评论

判断一个图是否是一个树（有向图，无向图）

Gin — Mon, 10 Dec 2012 13:50:00 GMT

摘要: 用并查集判断一个图是不是树阅读全文

Gin 2012-12-10 21:50 发表评论

线段相交与并查集（bnu5753,hdu1558)

Gin — Mon, 10 Dec 2012 13:31:00 GMT

这个主要是线段相交的处理，完全按照算法导论写一下几何就好了。并查集不想再说了。
叉积是好东西，同学们必须学会。

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<algorithm>
  4 #include<iomanip>
  5 using namespace std;
  6 const int maxnum=1000+1;
  7 #define rep(i,n,m) for(int i=(n);i<=(m);++i)
  8 #define re1(i,n) rep(i,1,n)
  9 struct point{
10     double x,y;
11     point(){
12
13     }
14     point(double  x,double y):x(x),y(y){
15
16     }
17     friend ostream& operator<<(ostream &out,point a){
18         out<<'('<<a.x<<','<<a.y<<')';
19         return out;
20     }
21 };
22 struct seg{
23     double x,y;
24     point from,to;
25     seg(){
26
27     }
28     seg(point a,point b):from(a),to(b){
29         double x1=a.x,x2=b.x;
30         double y1=a.y,y2=b.y;
31         x=x2-x1;
32         y=y2-y1;
33     }
34 };
35 double cross(seg a,seg b){
36     double x1=a.x,x2=b.x;
37     double y1=a.y,y2=b.y;
38     return x1*y2-y1*x2;
39 }
40 double cross(point p0,point p1,point p2){
41     return cross(seg(p0,p1),seg(p0,p2));
42 }
43 bool between(double a,double b,double x){
44     return x>=a && x<=b;
45 }
46 bool on_seg(point p1,point p2,point p0){
47     double x1=p1.x,x2=p2.x;
48     double y1=p1.y,y2=p2.y;
49     return between(min(x1,x2),max(x1,x2),p0.x) && between(min(y1,y2),max(y1,y2),p0.y);
50 }
51 bool intersect(point p1,point p2,point p3,point p4){
52     int d1=cross(p3,p4,p1);
53     int d2=cross(p3,p4,p2);
54     int d3=cross(p1,p2,p3);
55     int d4=cross(p1,p2,p4);
56     if(((d1>0 && d2<0)||(d1<0 && d2>0)) &&((d3>0 && d4<0) ||(d3<0 && d4>0)))
57         return true;
58     else if(d1==0 && on_seg(p3,p4,p1))
59         return true;
60     else if(d2==0 && on_seg(p3,p4,p2))
61         return true;
62     else if(d3==0 && on_seg(p1,p2,p3))
63         return true;
64     else if(d4==0 && on_seg(p1,p2,p4))
65         return true;
66     else
67         return false;
68
69 }
70 struct seg segs[maxnum];
71 int G[maxnum];
72 int num[maxnum];
73 int find(int x){
74     if(G[x]!=x)
75         G[x]=find(G[x]);
76     return G[x];
77 }
78 void u3n(int a,int b){
79     int x=find(a);
80     int y=find(b);
81     if(x==y)
82         return;
83     G[x]=y;
84     num[y]+=num[x];
85 }
86 void showline(int n,int m){
87     rep(i,n,m){
88         cout<<setw(6)<<i;
89     }
90     cout<<endl<<endl;
91 }
92 template<class T>
93 void show(T *a,int n,int m){
94     rep(i,n,m){
95         cout<<setw(6)<<a[i];
96     }
97     cout<<endl;
98 }
99 int main(){
100     int tcase;
101     scanf("%d",&tcase);
102     while(tcase--){
103         int m,n=0;
104         scanf("%d",&m);
105         char cmd[2];
106         re1(u,m){
107             G[u]=u;
108             num[u]=1;
109         }
110         re1(u,m){
111             scanf("%s",cmd);
112             if(cmd[0]=='P'){
113                 double x1,y1,x2,y2;
114                 scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
115                 segs[++n]=seg(point(x1,y1),point(x2,y2));
116         //        cout<
117                 re1(i,n-1){
118                     if(intersect(segs[i].from,segs[i].to,segs[n].from,segs[n].to))
119                         u3n(i,n);
120                 }
121             }else{
122                 int id;
123                 scanf("%d",&id);
124                 printf("%d\n",num[find(id)]);
125             }
126         }
127         //showline(1,6);
128         //show(G,1,6);
129         //show(num,1,6);
130         if(tcase)
131             printf("\n");
132     }
133 }

Gin 2012-12-10 21:31 发表评论

GGGin回来了

Gin — Mon, 10 Dec 2012 09:42:00 GMT

我的名字叫GGGin，希望通过自己的努力，来得到自己想要的东西。

Gin 2012-12-10 17:42 发表评论

我回来了（bnu5984，hdu1829）

Gin — Sun, 09 Dec 2012 15:32:00 GMT

我会继续更新这个东西，慢慢努力。
这次写的是poj上面的写过的一个并查集，但是可能水平高了一些。

这道题目的收获，一定要搞清楚逻辑关系，只有这样才能够不落下一种情况，这种情况多的问题，一定要处理好所有的情况。
关于并查集说了好多了，这个并查集就是一颗大树，每个元素都有和父母的关系，然后维护这个关系。

1#include<iostream>
2#include<cstdio>
3using namespace std;
4const int maxnum=2000+1;
5int G[maxnum],num[maxnum];
6#define re1(i,n) for(int i=(1);i<=(n);++i)
7template<class T>
8void show(T *a,int n,int m){
9    for(int i=n;i<=m;i++)
10        cout<<a[i]<<' ';
11    cout<<endl;
12}
13int find(int x){
14    int u=G[x];
15    if(u!=x){
16        G[x]=find(u);
17        num[x]=(num[x]+num[u])%2;
18    }
19    return G[x];
20}
21void u3n(int a,int b){
22    int x=find(a);
23    int y=find(b);
24    G[x]=b;
25    if(num[a]==0)
26        num[x]=1;
27    else
28        num[x]=0;
29
30}
31int main(){
32  //  #define home gggin
33    #ifdef home
34    freopen("7.txt","r",stdin);
35    #endif
36    int tcase,tnum=0;
37    scanf("%d",&tcase);
38    while(tcase--){
39        int n,m;
40        ++tnum;
41        scanf("%d%d",&n,&m);
42        re1(u,n){
43            G[u]=u;
44            num[u]=0;
45        }
46        bool flag=true;
47        re1(u,m){
48            int t1,t2;
49            scanf("%d%d",&t1,&t2);
50            if(find(t1)==find(t2) && num[t1]==num[t2])
51                flag=false;
52            else if(find(t1)!=find(t2)){
53                u3n(t1,t2);
54            }
55        }
56        //show(G,1,3);
57        //show(num,1,3);
58        if(!flag)
59            printf("Scenario #%d:\nSuspicious bugs found!",tnum);
60        else
61            printf("Scenario #%d:\nNo suspicious bugs found!",tnum);
62        printf("\n\n");
63    }
64}
65

Gin 2012-12-09 23:32 发表评论

2012-07-19 包宿后记

Gin — Thu, 19 Jul 2012 04:14:00 GMT

这个包宿不是计划中的,原因是因为岳同学的心事. 今天看了一个叫做3D打印技术的网易公开课,突然觉得,原来这个世界正在彻底的改变,而我们的生活也将彻底的改变.就像我的博客一样,还是没有坚持一直在写,中间断了很多天.都说人要和自己比,那我就想说,原来我还是有进步的...

刚刚洗过澡,准备出发了,和GF一起吃饭.

It is now that I get some feelings about love and dreams.

Gin 2012-07-19 12:14 发表评论

poj 1988 依然并查集

Gin — Tue, 10 Jul 2012 16:46:00 GMT

http://poj.org/problem?id=1988
这个题和我之前做的题目都不太一样,这里是很多个小的集合,这个也更像一个并查集,只不过我原来不知道,原来很多个集合也可以维护和爸爸的关系,也终于明白为什么figo觉得食物链那个并查集是水题了. 一个数组维护的是父节点(基本并查集), 还有一个v数组,是用来记录一个节点的值,这个值有这样的特点:计算本节点的值是下面的节点在并查集中是上面的节点的值+本节点的v. 意思就是说,要算x点到栈底有多远,就要x的父亲离栈底有多远+x离父亲有多远,所有的并查集都是维护和父亲的关系,我想了很久刚开始想错了方向. 记住:并查集是维护和父亲的关系的. 这道题还有一关,就是合并两个集合的时候要注意,一定要清楚加入到另一个节点下的树(叫新树),的值是多少,这个很好想,就是有东西放到了新树的下面,所以新树的根值就是原来那颗树里面的元素个数,所以还有一个数组,维护每一个集合的元素数目的num,最后一部在合并的时候,要把整个集合的元素数目 = 旧树+新树 (元素数目) 更新了. 然后路径压缩很简单,一直加值,自己的+父亲的,直到根为止.

代码如下:
code:
1 #include<iostream>

2 #include
3 using namespace std;
4 #define REP(i,from,to) for(int i=(from);i<=(to);++i)
5 const int N = 30002;
6 int a[N],v[N],num[N];
7 struct disset{
8     int *d,*v,*num,l;
9     disset(int *d,int *v,int* num,int l):d(d),v(v),num(num),l(l){
10         REP(i,1,l){
11             d[i]=i;
12             v[i]=0;
13             num[i]=1;
14         }
15     }
16     int find(int x){
17         int u = d[x];
18         if(u!=x){
19             d[x] = find(u);
20             v[x] += v[u];
21         }
22         return d[x];
23     }
24     void add(int x,int y){
25         int ux = d[x];
26         int uy = d[y];
27         d[ux] = uy;
28         v[ux] = num[uy];
29         num[uy] += num[ux];
30     }
31     int getv(int x){
32         return v[x];
33     }
34 }*s;
35 int work(char c,int x,int y){
36     int ux = s->find(x);
37     int uy = s->find(y);
38     if(c=='M'){
39         if(ux!=uy)
40             s->add(x,y);
41     }
42     else{
43         return s->getv(x);
44     }
45     return -1;
46 }
47 int main(){
48     int tcase;
49     while(scanf("%d",&tcase)!=EOF){
50         s = new struct disset(a,v,num,N-2);
51         while(tcase--){
52             char c[2];
53             int x,y=-1,ans;
54             scanf("%s",c);
55             if(c[0]=='M')
56                 scanf("%d%d",&x,&y);
57             else
58                 scanf("%d",&x);
59             ans=work(c[0],x,y);
60 //            REP(i,1,6)
61 //                cout<62 //            cout<
63             if(ans!=-1)
64                 printf("%d\n",ans);
65         }
66         delete s;
67     }
68     return 0;
69 }

Gin 2012-07-11 00:46 发表评论

poj 1703 2492 并查集(应用)

Gin — Mon, 09 Jul 2012 14:49:00 GMT

http://poj.org/problem?id=1703
这道题我写了没有多久,但是无端的MLE了很久,很多人不想看我唠叨,所以我还是开始说说这道题.

我天真的以为他给我的两个囚犯会在不同集合中,当然如果你不理解这道题,我说这个你还是不懂...
不好意思..我比较水..不要喷我.现在才说.

思路:
仅仅维护一个大的集合,这道题和poj1182的思路一样,不过写起来可以说更简单一点.我们把提供给我们的关系,全部都放到一颗树(一个集合)上面,而不是所谓的两个集合,那么关系呢?如何记录呢?就是我们不光维护我们的爸爸是什么,还要维护我们和爸爸的关系,和爸爸在同一个囚犯组织,or not. 然后每次添加新元素的时候一定要注意判断(这两个元素是不是在同一个集合中,这个是非常的重要的,否则会出现无限递归的情况,然后MLE.也就是我刚开始说的..天真的以为..),添加的时候举个例子,在纸上画画.x 的爸爸是 p, x的值可能为0or1,0为同一个阵营,1为不同的阵营,而y与x不同阵营且一共两个阵营,所以知道 v[x]=1--->v[y]=0,v[x]=1--->v[y]=1 ====> v[y]=(v[x]+1)%2; 然后就是询问了,找到根,然后判断两个值是否相等即可,原因就是都和同一个父亲比较那么值相同则同类(如果你要问我为什么是和同一个父亲比较,我告诉你..你回去学并查集,然后学路径压缩,然后会发现他们都在一个父亲下面).

code:

1 #include
2 #include
3 const int N = 100002;
4 using namespace std;
5 #define REP(i,from,to) for(int i=(from);i<=(to);++i)
6 struct disset{
7     int *d,*v,l;
8     disset(int *d,int *v,int l):d(d),v(v),l(l){
9         REP(i,1,l){
10             d[i]=i;
11             v[i]=0;
12         }
13     }
14     int find(int x){
15         int u = d[x];
16         if(u!=x){
17             d[x] = find(u);
18             v[x] = (v[x] + v[u])%2;
19         }
20         return d[x];
21     }
22     void diff(int x,int y){
23         int u = find(x);
24         d[u] = y;
25         v[u] = (v[x]+1) % 2;
26     }
27 };
28 int a[N],v[N];
29 struct disset *s ;
30 int work(char c,int x,int y){
31     int ux = s->find(x);
32     int uy = s->find(y);
33     if(c=='A'){
34         if(ux!=uy)
35             return 0;
36         else{
37             if(v[x]==v[y])
38                 return 2;
39             else
40                 return 1;
41         }
42     }
43     else{
44         if(ux!=uy)
45             s->diff(x,y);
46     }
47     return -1;
48 }
49 int main(){
50     int ccase;
51     scanf("%d",&ccase);
52     while(ccase--){
53         int n,m;
54         scanf("%d%d",&n,&m);
55         s = new struct disset(a,v,n);
56         while(m--){
57             char c[2];
58             int x,y;
59             scanf("%s%d%d",c,&x,&y);
60             int ans = work(c[0],x,y);
61         //    REP(i,1,5)
62         //        cout<63         //    cout<
64             if(ans==0)
65                 printf("Not sure yet.\n");
66             else if(ans==1)
67                 printf("In different gangs.\n");
68             else if(ans==2)
69                 printf("In the same gang.\n");
70         }
71         delete s;
72     }
73     return 0;

74 }
做到后来发现还有一道题..原来是我少见多怪了...其实都是并查集大水题..2492,也是poj上面的代码如下:
code:

1 #include
2 #include
3 using namespace std;
4 #define REP(i,from,to) for(int i=(from);i<=(to);++i)
5 struct disset{
6     int *d,*v,l;
7     disset(int *d,int *v,int l):d(d),v(v),l(l){
8         REP(i,1,l){
9             d[i]=i;
10             v[i]=0;
11         }
12     }
13     bool is_same(int x,int y){
14         return v[x]==v[y];
15     }
16     int find(int x){
17         int u = d[x];
18         if(u!=x){
19             d[x] = find(u);
20             v[x] = (v[x]+v[u])%2;
21         }
22         return d[x];
23     }
24     void add(int x,int y){
25         int u = find(x);
26         d[u] = y;
27         v[u] = ( v[x] + 1 )%2;
28     }
29 }*s;
30 bool work(int x,int y){
31     int ux = s->find(x);
32     int uy = s->find(y);
33     if(ux==uy){
34         if(s->is_same(x,y))
35             return false;
36     }
37     else{
38         s->add(x,y);
39     }
40     return true;
41 }
42 const int N = 100002;
43 int a[N],v[N];
44 int main(){
45     int tcase;
46     scanf("%d",&tcase);
47     REP(ccase,1,tcase){
48         printf("Scenario #%d:\n",ccase);
49         bool ans=true;
50         int n,ttcase;
51         scanf("%d%d",&n,&ttcase);
52         s = new struct disset(a,v,n);
53         while(ttcase--){
54             int x,y;
55             scanf("%d%d",&x,&y);
56             if(!work(x,y))
57                 ans = false;
58         }
59         delete s;
60         if(!ans)
61             printf("Suspicious bugs found!\n\n");
62         else
63             printf("No suspicious bugs found!\n\n");
64
65     }
66 }

Gin 2012-07-09 22:49 发表评论

poj 1182 并查集(应用)

Gin — Sun, 08 Jul 2012 15:15:00 GMT

http://poj.org/problem?id=1182

维护每个孩子和父亲的关系,0=和父亲同类,1=可以吃父亲,2=可以被父亲吃.

整个题,只有一个主要集合,这个和其他并查集不一样有很多大小不同的集合,然后合并,这个题目是每次将一个未知的点插入到已知关系的集合中,并建立与父亲的关系,然后每次查找的路径压缩让两个节点可以通过父亲来判断他们的关系,比如 v[x]=1 v[y]=2 说明x吃了他父亲,y能被他父亲吃,所以y可以吃掉x,这样就能找到关系了,路径压缩的时候要理解好递归的思路,每次通过自己的父亲算出与上一个父亲的关系,自己画一画然后思考.这次比较幸运,竟然能够一次AC,说明我的编码能力有提高. 说真的,结构体类,真的挺好玩的...构造函数可以写struct...

code:

1 #include
2 #include
3 using namespace std;
4 #define REP(i,from,to) for(int i=(from);i<=(to);++i)
5 int a[50001];
6 int v[50001];
7 int n;
8 struct disset{
9     int *d;
10     int *v;
11     int l;
12     disset(int *_d,int *_v,int _l):d(_d),v(_v),l(_l){
13         REP(i,1,l){
14             a[i]=i;
15             v[i]=0;
16         }
17     }
18     int find(int x){
19         int u = d[x];
20         if(u!=x){
21             d[x] = find(u);
22             v[x] = (v[x]+v[u]) % 3;
23         }
24         return d[x];
25     }
26     void same(int x,int y){
27         int u = find(x);
28         d[u] = y;
29         if(v[x]==0)
30             v[u]=0;
31         else if(v[x]==1)
32             v[u]=2;
33         else
34             v[u]=1;
35
36     }
37     void eat(int x,int y){
38         int u = find(x);
39         d[u]=y;
40         if(v[x]==2)
41             v[u]=2;
42         else if(v[x]==0)
43             v[u]=1;
44         else
45             v[u]=0;
46     }
47     bool is_eat(int x,int y){
48         if(v[x]==0 && v[y]==2 ||
49             v[x]==1 && v[y]==0 ||
50             v[x]==2 && v[y]==1)
51             return true;
52         return false;
53     }
54 };
55 struct disset *s;
56 bool sentence(int d,int x,int y){
57     if(x>n || y>n)
58         return false;
59     if(d==1){
60         int ux = s->find(x);
61         int uy = s->find(y);
62         if(ux!=uy){
63             s->same(x,y);
64         }
65         else if(v[x]!=v[y])
66             return false;
67     }
68     else{
69         int ux = s->find(x);
70         int uy = s->find(y);
71         if(ux!=uy){
72             s->eat(x,y);
73         }
74         else if(!s->is_eat(x,y))
75             return false;
76     }
77     return true;
78 }
79 int main(){
80     int ccase,ans=0;
81     scanf("%d%d",&n,&ccase);
82     //REP(i,1,5)
83     //    cout<84     //cout<
85     s = new struct disset(a,v,n);
86     while(ccase--){
87         int d,x,y;
88         scanf("%d%d%d",&d,&x,&y);
89         if(!sentence(d,x,y))
90             ans++;
91
92     //    REP(i,1,5)
93     //        cout<94     //    cout<
95     }
96     printf("%d\n",ans);
97     return 0;
98 }

Gin 2012-07-08 23:15 发表评论