题目是来自HZW的博客(构造题我是各种不会...)

Solved 1 / 1 A CodeForces 500A New Year Transportation
Solved 1 / 1 B CodeForces 437C The Child and Toy
Solved 1 / 2 C CodeForces 510C Fox And Names
Solved 1 / 3 D CodeForces 475B Strongly Connected City
Solved 1 / 2 E CodeForces 639B Bear and Forgotten Tree 3
Solved 1 / 3 F CodeForces 623A Graph and String
Solved 1 / 20 G CodeForces 449B Jzzhu and Cities
Solved 1 / 4 H CodeForces 543B Destroying Roads

A

给一些线性排列的节点,每个节点有向后面第ai个节点的单向边,问是否能从1到T

1≤n,ai≤10^5

//直接模拟,1能到的点,所能到的点也是能到的,最后检查t
//
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
int num[maxn];
int vis[maxn]; int main(){
//#define test
#ifdef test
freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif while(cin>>n>>m){
memset(vis,0,sizeof vis);
memset(num,0,sizeof num);
for(int i=1;i<n;i++){
cin>>num[i];
}
vis[1]=1;
for(int i=1;i<n;i++){
if(!vis[i])continue;
vis[i+num[i]]=true;
}
if(vis[m])puts("YES");
else puts("NO");
} #ifdef test
fclose(stdin);fclose(stdout);system("out.txt");
#endif
return 0;
}

B

n个点.m条边的无向图,输入保证不含重边

删除一个点的代价是与这个点相邻的剩余点的权值和,求将所有点删除的最小代价

/*
很巧妙的思路,核心点在于,假设a,b两点相连
若先删除a,最终代价就是 b的权值+删除剩下所有点的花费
若先删除b,最终代价就是 a的权值+删除剩下所有点的花费
这个规则对于所有的相邻点都成立,简单来说,我们可以通过改变删除顺序,贪心的得到最小的代价
简单来说,对于任意一个边,其权值较大的一个端点就是我们先要删除的,也就是说代价是所有边中权值较小的一端
*/
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
int num[maxn];
int vis[maxn]; int main(){
//#define test
#ifdef test
freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif while(cin>>n>>m){
int ans=0;
for(int i=1;i<=n;i++) cin>>num[i];
while(m--){
int a,b;
cin>>a>>b;
ans+=min(num[a],num[b]);
}
cout<<ans<<endl;
} #ifdef test
fclose(stdin);fclose(stdout);system("out.txt");
#endif
return 0;
}

C

给定n个字符串,问是否存在一种自字母表,使得让这些字符串按照输入顺序排列满足字典序

1≤n,|S|≤100

直接按照输入顺序遍历,并建立一条从大字母到小字母的边,并记录所有点的入度

我们考虑dfs

对于入度为0的字母,自然放在新字母表的前端,然后把该字母节点删去,也就是把所有小于它的字母入度减一,如果入度为零了,自然也就可以放进剩下字母表的前端了

直到所有字母都进入字母表,进行检查是否合法,如果有的字母入度不为零,也就是还没入字母表,不存在答案

注意如果一个字符串是另一个字符串的前缀,它的字典序是更小的,也就是说如果一个字符串比他的前缀还靠前,不存在答案

其实这个过程也就是一个拓扑排序

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <vector>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
int stk[maxn];
int top;
int deg[maxn];
int alp[123];
vector<int>g[maxn];
char s[123][123];
int ans[123];
int main(){
//#define test
#ifdef test
freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif while(cin>>n){
top=0;
for(int i=0;i<30;i++)g[i].clear();
memset(deg,0,sizeof deg);
// for(int i=0;i<26;i++) alp[i]=i;
for(int i=0;i<n;i++){
cin>>s[i];
}
int flag=1;
for(int i=0;i<n&&flag;i++){
int len=strlen(s[i]);
for(int j=i+1;j<n&&flag;j++){
for(int k=0;k<len;k++){
if(k>=strlen(s[j])){
flag=0;
break;
}
if(s[i][k]!=s[j][k]) {
deg[s[j][k]-'a'+1]++;
g[s[i][k]-'a'+1].push_back(s[j][k]-'a'+1);
break;
}
}
}
}
for(int i=1;i<=26;i++)if(!deg[i])stk[++top]=i;
int cnt=0;
while(top){
int now=stk[top--];
alp[cnt++]=now;
for(int i=0;i<g[now].size();i++){
int to=g[now][i];
deg[to]--;
if(!deg[to]){
stk[++top]=to;
}
}
}
for(int i=1;i<=26;i++){
if(deg[i]){
flag=0;
break;
}
}
if(!flag)puts("Impossible");
else {
for(int i=0;i<26;i++){
cout<<((char)(alp[i]+'a'-1));
}
cout<<endl;
}
}
#ifdef test
fclose(stdin);fclose(stdout);system("out.txt");
#endif
return 0;
}

D

一个网格,你可以沿着格子上的线移动,

每一条横着贯穿的线只能向左或者向右走

每一个竖着贯穿的线只能向上或者向下走

问是否任意两点可达

dfs(我并不会),或者tarjan(敲得很舒服),写完看题解说可以只看外围情况...太菜了Orz

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
char hor[123];
char ver[123];
int g[23][23][23][23];
int vis[123][123];
const int dir[4][2]={1,0,-1,0,0,1,0,-1};
#define dx dir[d][0]
#define dy dir[d][1]
void dfs(int nx,int ny){
vis[nx][ny]++;
for(int d=0;d<4;d++){
int x=nx+dx;
int y=ny+dy;
if(x&&y&&x<=n&&y<=m&&g[nx][ny][x][y]&&!vis[x][y]){
dfs(x,y);
}
}
}
int main(){ #ifdef test
freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif
while(cin>>n>>m){
cin>>(hor+1)>>(ver+1);
memset(g,0,sizeof g);
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(hor[i]=='<'&&j){
g[i][j][i][j-1]=1;
}else if(hor[i]=='>'&&j<m){
g[i][j][i][j+1]=1;
}
}
}
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
if(ver[i]=='v'&&j<n){
g[j][i][j+1][i]=1;
}else if(ver[i]=='^'&&j){
g[j][i][j-1][i]=1;
}
}
}
int flag=1;
memset(vis,0,sizeof vis);
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
memset(vis,0,sizeof vis);
dfs(i,j);
for(int k=1;k<=n;k++){
for(int q=1;q<=m;q++){
if(!vis[k][q]){
flag=0;
k=q=1e9;
}
}
}
if(!flag) i=j=1e9;
}
}
if(flag) puts("YES");
else puts("NO");
} #ifdef test
fclose(stdin);fclose(stdout);system("out.txt");
#endif
return 0;
}
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
char hor[123],ver[123];
int stk[1234],top,cnt,dfn[1234],low[1234],numc,belong[1234];
int vis[1234];
struct node {
int to,next;
}e[maxn];
int nume,head[1234];
void add(int a,int b){
e[nume]=(node){b,head[a]};
head[a]=nume++;
}
void tdfs(int now){
dfn[now]=low[now]=++cnt;
stk[top++]=now;
vis[now]=1;
for(int i=head[now];~i;i=e[i].next){
int to=e[i].to;
if(!dfn[to]){tdfs(to);low[now]=min(low[now],low[to]);}
else if(vis[to]) low[now]=min(low[now],low[to]);
}
if(low[now]==dfn[now]){
numc++;
int to;
do{
to=stk[--top];
belong[to]=numc;
vis[to]=0;
}while(to!=now);
}
}
void tarjan(int numv=n){
for(int i=1;i<=numv;i++){
if(!dfn[i]) tdfs(i);
}
}
int main(){
//#define test
#ifdef test
freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif while(cin>>n>>m){
nume=top=numc=cnt=0;
memset(head,-1,sizeof head);
memset(dfn,0,sizeof dfn);
memset(low,0,sizeof low);
memset(belong,0,sizeof belong);
memset(vis,0,sizeof vis);
cin>>(hor+1)>>(ver+1);
for(int i=1;i<=n;i++){
if(hor[i]=='<')
for(int j=2;j<=m;j++)
add((i-1)*m+j,(i-1)*m+j-1);
else for(int j=1;j<m;j++)
add((i-1)*m+j,(i-1)*m+j+1);
}
for(int i=1;i<=m;i++){
if(ver[i]=='v')
for(int j=1;j<n;j++)
add((j-1)*m+i,(j)*m+i);
else for(int j=2;j<=n;j++)
add((j-1)*m+i,(j-2)*m+i);
}
tarjan(n*m);
puts((numc==1)?"YES":"NO");
} #ifdef test
fclose(stdin);fclose(stdout);system("out.txt");
#endif
return 0;
}

E

给一个树的3种属性,点数,深度,直径

让你构造出来其中一种

先判断是否可行

再去构造深度

再去构造剩下的满足直径

再把其他点放在..不影响之前性质的地方(我一开始写的链式前向星存图,其实只用保留前驱节点就行..)

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
struct node {int to,cost,next;}e[maxm];int head[maxn],nume;
void add(int a,int b,int c=1){e[++nume]=(node){b,c,head[a]};head[a]=nume;}
int pre[maxn]; int main(){
//#define test
#ifdef test
freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif while(cin>>n>>k>>m){
if(k<m||k==n||k==1&&n>2||k>2*m){
puts("-1");
continue;
}
memset(pre,0,sizeof pre);
for(int i=2;i<=m+1;i++) pre[i]=i-1;
(m+2<=k+1) pre[m+2]=1;
for(int i=m+3;i<=k+1;i++) pre[i]=i-1;
for(int i=k+2;i<=n;i++) pre[i]=m;
for(int i=2;i<=n;i++) cout<<pre[i]<<' '<<i<<endl;
} #ifdef test
fclose(stdin);fclose(stdout);system("out.txt");
#endif
return 0;
}

F

给n个点m个边

告诉你这个图其实是一个abc三个字母的字符串构成的

如果Si和Sj差距小于等于1,则连接一条无向边

问一个合法解,也就是问一种合法的染色

首先,记录入度

如果入度等于n-1,也就是和所有其他点都有边,这个字母自然是b

然后,对于任意一对没有染色的点,自然一个是a,一个是c

然后,其中和a连接的,自然是a,反之是c

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e3+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
int deg[maxn];
int g[maxn][maxn];
int ans[maxn];
int main(){
//#define test
#ifdef test
freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif while(cin>>n>>m){
memset(g,0,sizeof g);
memset(deg,0,sizeof deg);
for(int i=0;i<m;i++){
int a,b;
scanf("%d%d",&a,&b);
g[a][b]=g[b][a]=1;
deg[a]++;
deg[b]++;
}
memset(ans,0,sizeof ans);
for(int i=1;i<=n;i++){
if(deg[i]==n-1) ans[i]=2;
}
for(int i=1;i<=n;i++){
if(ans[i]) continue;
for(int j=i+1;j<=n;j++){
if(!g[i][j]){
ans[i]=1;ans[j]=3;
for(int k=1;k<=n;k++){
if(k==i||k==j||ans[k]) continue;
if(g[k][i]) ans[k]=1;
if(g[k][j]) ans[k]=3;
}
}
}
}
int sin=1;
for(int i=1;i<=n;i++){
if(!ans[i]){
sin=0;
break;
}
}
for(int i=1;i<=n&&sin;i++){
for(int j=i+1;j<=n;j++){
if(g[i][j]&&abs(ans[i]-ans[j])>1){
sin=0;
break;
}
if(!g[i][j]&&abs(ans[i]-ans[j])<=1){
sin=0;
break;
}
}
}
if(sin){
puts("YES");
for(int i=1;i<=n;i++)cout<<(char)(ans[i]+'a'-1);
cout<<endl;
}
else puts("NO");
} #ifdef test
fclose(stdin);fclose(stdout);system("out.txt");
#endif
return 0;
}

G

给一个无向图,又有一些额外边是从起点直接到某些点的,存在重边

问你最多删除多少个额外路,使得每个点到起点的最短路不变

先构造图,跑一边spfa,然后如果有特殊路大于当前最短路,直接删掉

否则枚举这个点的边,如果有和这个点相邻的点+边权等于到该点的特殊路径,也删掉

而对于任意一点

如果特殊路径被保存了一个,其他到该点的特殊路径也都应该被删除

如果该点的特殊路径等于其他走普通路径的距离,其他所有到该点的特殊路径也应该被删除

标记,剪枝一下即可

注意,该题卡spfa,但是用spfa+slf优化可以秒杀

当然,也可能是我这个做法比较臭(也有可能是因为重边太多了)

能想到的还有比如记录入度,如果入度大于1且有同样长度,就删除,速度应该差不多

还有就是先跑一遍spfa,然后加入特殊路之前先剪枝一波,然后再在原图的基础上跑一遍spfa

或者就是把有特殊路的节点标记上,如果这个点被松弛了,自然这个地方的特殊路就会被删除,最后统计...

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
#define ll long long
int casn,n,m,k;
struct node {int to;int cost;int next;}e[maxm];int head[maxn],nume;
inline void add(int a,int b,int c=1){e[++nume]=(node){b,c,head[a]};head[a]=nume;}
int road[maxn];
ll dis[maxn];
bool vis[maxn];
int que[maxn];
int go[maxn]; void spfa(int st=1,int ed=n){
int top=0,end=0,now;
memset(dis,INF,sizeof dis);
memset(vis,0,sizeof vis);
que[end++]=st,dis[st]=0;
while(top!=end){
now=que[top++],top%=maxn;
vis[now]=false;
for(int i=head[now];i;i=e[i].next){
int to=e[i].to;
if(now==to) continue;
if(dis[now]+e[i].cost<dis[to]){
dis[to]=dis[now]+e[i].cost;
if(!vis[to]){
vis[to]=true;
if(dis[to]<dis[que[top]]){
top--;
if(top==-1)top=maxn-1;
que[top]=to;
}else{
que[end++]=to;
end%=maxn;
}
}
}
}
}
} int main(){
//#define test
#ifdef test
freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif cin>>n>>m>>k;
for(int i=0;i<m;i++){
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
add(b,a,c);
}
int ans=0;
int cnt=0;
for(int i=1;i<=k;i++){
int a,b;
scanf("%d%d",&a,&b);
add(1,a,b);
road[i]=b;
go[i]=a;
}
spfa();
memset(vis,0,sizeof vis);
for(int i=1;i<=k;i++){
if(vis[go[i]]||road[i]>dis[go[i]]){
ans++;
continue;
}
for(int j=head[go[i]];j;j=e[j].next){
int to=e[j].to;
if(dis[go[i]]==dis[to]+e[j].cost){
ans++;
break;
}
}
vis[go[i]]=1;
}
cout<<ans<<endl; #ifdef test
fclose(stdin);fclose(stdout);system("out.txt");
#endif
return 0;
}

H

给一个无权图,问你如何删除最多的边

才能使得s1 t1的距离依然大于l1,s2 t2的距离依然大于l2

n<=3000

原题等价于最少多少条边可满足l1,l2的条件,其他的边都可以删掉

首先如果两个路无交集,就是要保留s1 t1,s2 t2的路径边数之和

然后n^2枚举共同路径,如果走共同路径的路径长度满足条件,就更新答案

注意点数可以达到3000,我的floyd一直T,改成n次spfa+slf优化就ac了...原谅我spfa敲得太顺手了..

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
struct node {int to,cost,next;}e[maxm];int head[maxn],nume;
void add(int a,int b,int c=1){e[++nume]=(node){b,c,head[a]};head[a]=nume;}
int s1,s2,t1,t2,l1,l2;
int dis[3000+15][3000+15];
bool vis[maxn];
int que[maxn];
void spfa(int st=1,int ed=n){
int top=0,end=0,now;
memset(vis,0,sizeof vis);
que[end++]=st,dis[st][st]=0;
while(top!=end){
now=que[top++],top%=maxn;
vis[now]=false;
for(int i=head[now];i;i=e[i].next){
int to=e[i].to;
if(now==to) continue;
if(dis[st][now]+e[i].cost<dis[st][to]){
dis[st][to]=dis[st][now]+e[i].cost;
if(!vis[to]){
vis[to]=true;
if(dis[now][to]<dis[now][que[top]]){
top--;
if(top==-1)top=maxn-1;
que[top]=to;
}else{
que[end++]=to;
end%=maxn;
}
}
}
}
}
} int main(){
//#define test
#ifdef test
freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif
ios::sync_with_stdio(false);
cin>>n>>m;
memset(dis,0x3f,sizeof dis);
for(int i=0;i<m;i++){
int a,b;
cin>>a>>b;
add(a,b,1);
add(b,a,1);
}
cin>>s1>>t1>>l1;
cin>>s2>>t2>>l2;
for(int i=1;i<=n;i++){
spfa(i);
}
int flag=1;
if(dis[s1][t1]>l1||dis[s2][t2]>l2){
flag=0;
}
int ans=dis[s1][t1]+dis[s2][t2];
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
int d1=dis[s1][i]+dis[j][t1];
int d2=dis[s2][i]+dis[j][t2];
int mid=dis[i][j];
int d3=dis[s1][j]+dis[i][t1];
int d4=dis[s2][j]+dis[i][t2];
if(d1+mid<=l1&&d2+mid<=l2){
ans=min(ans,d1+d2+mid);
}
if(d3+mid<=l1&&d4+mid<=l2){
ans=min(ans,d3+d4+mid);
}
if(d1+mid<=l1&&d4+mid<=l2){
ans=min(ans,d1+d4+mid);
}
if(d3+mid<=l1&&d2+mid<=l2){
ans=min(ans,d3+d2+mid);
}
}
}
if(flag) cout<<m-ans<<endl;
else puts("-1");
#ifdef test
fclose(stdin);fclose(stdout);system("out.txt");
#endif
return 0;
}

专题:CF图论杂题的更多相关文章

  1. dp杂题(根据个人进度选更)

    ----19.7.30 今天又开了一个新专题,dp杂题,我依旧按照之前一样,这一个专题更在一起,根据个人进度选更题目; dp就是动态规划,本人认为,动态规划的核心就是dp状态的设立以及dp转移方程的推 ...

  2. Atcoder&CodeForces杂题11.7

    Preface 又自己开了场CF/Atcoder杂题,比昨天的稍难,题目也更有趣了 昨晚炉石检验血统果然是非洲人... 希望这是给NOIP2018续点rp吧 A.CF1068C-Colored Roo ...

  3. 2019暑期金华集训 Day6 杂题选讲

    自闭集训 Day6 杂题选讲 CF round 469 E 发现一个数不可能取两次,因为1,1不如1,2. 发现不可能选一个数的正负,因为1,-1不如1,-2. hihoCoder挑战赛29 D 设\ ...

  4. 贪心/构造/DP 杂题选做Ⅱ

    由于换了台电脑,而我的贪心 & 构造能力依然很拉跨,所以决定再开一个坑( 前传: 贪心/构造/DP 杂题选做 u1s1 我预感还有Ⅲ(欸,这不是我在多项式Ⅱ中说过的原话吗) 24. P5912 ...

  5. 正睿OI DAY3 杂题选讲

    正睿OI DAY3 杂题选讲 CodeChef MSTONES n个点,可以构造7条直线使得每个点都在直线上,找到一条直线使得上面的点最多 随机化算法,check到答案的概率为\(1/49\) \(n ...

  6. wangkoala杂题总集(根据个人进度选更)

    CQOI2014 数三角形 首先一看题,先容斥一波,求出网格内选三个点所有的情况,也就是C(n*m,3);然后抛出行里三点共线的方案数:C(n,3)*m; 同理就有列中三点共线的方案数:n*C(m,3 ...

  7. 11.07图论水题Test

    11.07图论水题Test 题目 描述 做法 \(BSOJ6378\) 在\(i\)位置可以到\(i+a_i\)或\(i+b_i\)求\(1\rightarrow n\)字典序最小路径 判可达性后贪心 ...

  8. Codeforces 杂题集 2.0

      记录一些没有写在其他随笔中的 Codeforces 杂题, 以 Problemset 题号排序   1326D2 - Prefix-Suffix Palindrome (Hard version) ...

  9. 【Java面试】-- 杂题

    杂题 2019-11-03  21:09:37  by冲冲 1.类加载器的双亲委派机制 类加载器:把类通过类加载器加载到JVM中,然后转换成class对象(通过类的全路径来找到这个类). 双亲委派机制 ...

随机推荐

  1. [JUC-2]AbstractQueuedSynchronizer源码分析

    AbstactQueuedSynchronizer的基本数据结构 AbstractQueuedSynchronizer的基本数据结构为Node,关于Node,JDK作者写了详细的注释,这里我大致总结几 ...

  2. HDU 1064(求平均数 **)

    题意是求 12 个浮点数的平均数,这题不用读题,看到运行时间为 200 ms 再看下样例就能猜出题目的要求了,代码如下: #include <bits/stdc++.h> using na ...

  3. 解析ArcGis的标注(二)——认识ArcGis标注标签

    该“标注”系列博文的标注引擎使用“标准标注引擎(standard label engine)”,这个概念如不知道,可不理会,ArcGis默认标注引擎就是它. 本篇的标注语句解析使用VBScript,注 ...

  4. 045、安装Docker Machine (2019-03-08 周五)

    参考https://www.cnblogs.com/CloudMan6/p/7223599.html   前面我们的实验中只有一个docker host ,所有的容器都是运行在这一个host上的.但在 ...

  5. final 关键字:用来修饰类,方法,成员变量,局部变量

    final 关键字:用来修饰类,方法,成员变量,局部变量 表示最终的不可变的 1.final修饰一个类 表示当前的类不能有子类,也就是不能将一个类作为父类 格式: public final class ...

  6. CSS脱离文档流&浮动

    什么是文档流? 将窗体从上至下分成一行一行,并在每行中按从左至右依次排放元素,称为文档流,也称为普通流.这个应该不难理解,HTML中全部元素都是盒模型,盒模型占用一定的空间,依次排放在HTML中,形成 ...

  7. GreenDao 直接执行SQL的方法

    try { DaoSession session=MyApplication.getInstances().getDaoSession(); long fromId=-1; String strSql ...

  8. 二十九、Linux 进程与信号——minishell(2)

    编程内容: 1.完成  echo env export 命令 2.完成前后台进程 3.完成重定向 完整代码如下: 29.1 主函数.通用头文件和Makefile 29.1.1 主函数 mshell_m ...

  9. treap基本操作

    利用rand保持堆的特性 const int N=; int ls[N],rs[N],v[N],p[N],cnt[N],siz[N]; // 权值 优先级 inline void update(int ...

  10. 【游戏开发&Unity】捏脸系统(附源码)

    本着“没有捏脸系统算什么RPG”的想法,着手做一个2d简易捏脸demo.其实换装游戏都差不多啦~ github代码地址:Simple-Character-Edit-System (Unity版本:5. ...