2-sat小结

最新推荐文章于 2020-09-02 16:32:34 发布
最新推荐文章于 2020-09-02 16:32:34 发布
阅读量448 收藏
点赞数
分类专栏： 图论——2-sat 文章标签： poj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/neko01/article/details/23969253
版权 

<span style="color:#330033;background-color: rgb(255, 255, 255);">最近做了一些2-sat的题，作为模板性很强的题，网上对于原理讲的都比较详细，这里就不再重复，图论题主要是建图，对于2-sat模型则是要找出两两只能选择其中一个的元素，分别记为a和!a，然后对于这些元素连选A必须选B的边，连A到B，就可以套模板求解了。</span>
<span style="color:#330033;background-color: rgb(255, 255, 255);">题目链接：http://poj.org/problem?id=3678</span>
<span style="color:#330033;background-color: rgb(255, 255, 255);">说明：裸的2-sat，考察的就是对于每一个逻辑条件怎么加边。</span>
/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
    int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int scc,top,index;
void init()
{
    scc=top=index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
bool solve(int n)
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    for(int i=0;i<2*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<n;i++)
    {
        if(belong[i]==belong[i+n])
            return false;
    }
    return true;
}
int main()
{
    int n,m,a,b,c;
    char s[10];
    scanf("%d%d",&n,&m);
    init();
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d%s",&a,&b,&c,s);
        if(s[0]=='A')
        {
            if(c==1)
            {
                addedge(a,b);
                addedge(b,a);
                addedge(a+n,a); //±ØÐëÑ¡a
                addedge(b+n,b);
            }
            else
            {
                addedge(a,b+n);
                addedge(b,a+n);
            }
        }
        if(s[0]=='O')
        {
            if(c==1)
            {
                addedge(a+n,b);
                addedge(b+n,a);
            }
            else
            {
                addedge(a+n,b+n);
                addedge(b+n,a+n);
                addedge(a,a+n);
                addedge(b,b+n);
            }
        }
        if(s[0]=='X')
        {
            if(c==1)
            {
                addedge(a,b+n);
                addedge(b,a+n);
                addedge(a+n,b);
                addedge(b+n,a);
            }
            else
            {
                addedge(a,b);
                addedge(b,a);
                addedge(a+n,b+n);
                addedge(b+n,a+n);
            }
        }
    }
    if(solve(n))
        printf("YES\n");
    else
        printf("NO\n");
    return 0;
}
poj3905 Perfect Election

链接：http://poj.org/problem?id=3905

说明：意思是每个人的两个要求至少满足一个，那么如果这个条件没满足另一个必须满足，建图解即可。

代码：

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
    int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int scc,top,index;
void init()
{
    scc=top=index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
bool solve(int n)
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    for(int i=0;i<2*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<n;i++)
    {
        if(belong[i]==belong[i+n])
            return false;
    }
    return true;
}
int main()
{
    int n,m,a,b,k,j;
    while(scanf("%d%d",&n,&m)==2)
    {
        init();
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&a,&b);
            if(a>0&&b>0)
            {
                a--,b--;
                addedge(a+n,b);
                addedge(b+n,a);
            }
            else if(a>0)
            {
                b=-b;
                a--,b--;
                addedge(a+n,b+n);
                addedge(b,a);
            }
            else if(b>0)
            {
                a=-a;
                a--,b--;
                addedge(b+n,a+n);
                addedge(a,b);
            }
            else
            {
                a=-a,b=-b;
                a--,b--;
                addedge(a,b+n);
                addedge(b,a+n);
            }
        }
        if(solve(n))
            printf("1\n");
        else
            printf("0\n");
    }
    return 0;
}
poj3683

链接：http://poj.org/problem?id=3683

说明：神父只能参加一个主持仪式，然后枚举各个的时间关系连边建图，这个题要求输出一种方案，用的是赵爽论文的那种做法比较麻烦，代码略长。

代码：

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
    int to,next;
}edge[maxm],edge1[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int indeg[maxn];//rudu
int col[maxn]; //ranse
int cf[maxn];
int scc,top,index,tot1;
int s[maxn],t[maxn],d[maxn];
void init()
{
    scc=top=index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void addedge1(int u,int v)
{
    edge1[tot1].to=v;
    edge1[tot1].next=head[u];
    head[u]=tot1++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
void solve(int n)
{
    int flag=0;
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    for(int i=0;i<2*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<n;i++)
    {
        if(belong[i]==belong[i+n])
        {
            flag=1;
            break;
        }
        cf[belong[i]]=belong[i+n];
        cf[belong[i+n]]=belong[i];
    }
    if(flag==1)
    {
        printf("NO\n");
        return;
    }
    printf("YES\n");
    memset(head,-1,sizeof(head));
    memset(indeg,0,sizeof(indeg));
    tot1=0;
    for(int i=0;i<2*n;i++)
    {
        for(int j=head[i];j!=-1;j=edge[i].next)
        {
            int v=edge[i].to;
            if(belong[i]!=belong[v])
            {
                addedge1(belong[v],belong[i]);
                indeg[belong[i]]++;
            }
        }
    }
    queue <int>q;
    memset(col,0,sizeof(col));
    for(int i=1;i<=scc;i++)
        if(indeg[i]==0)
            q.push(i);
    while(!q.empty())
    {
        int cur=q.front();
        q.pop();
        if(col[cur]==0)
        {
            col[cur]=1;
            col[cf[cur]]=-1;
        }
        for(int i=head[cur];i!=-1;i=edge1[i].next)
        {
            int u=edge[i].to;
            if(--indeg[u]==0)
                q.push(u);
        }
    }
    for(int i=0;i<n;i++)
    {
        if(col[belong[i]]==1)
        {
            printf("%02d:%02d %02d:%02d\n",s[i]/60,s[i]%60,(s[i]+d[i])/60,(s[i]+d[i])%60);
        }
        else
        {
            printf("%02d:%02d %02d:%02d\n",(t[i]-d[i])/60,(t[i]-d[i])%60,(t[i])/60,(t[i])%60);
        }
    }
}
void buildmap(int n)
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<i;j++)
        {
            if(min(s[i]+d[i],s[j]+d[j])>max(s[i],s[j]))
            {
                addedge(i,j+n);
                addedge(j,i+n);
            }
            if(min(s[i]+d[i],t[j])>max(s[i],t[j]-d[j]))
            {
                addedge(i,j);
                addedge(j+n,i+n);
            }
            if(min(t[i],s[j]+d[j])>max(t[i]-d[i],s[j]))
            {
                addedge(i+n,j+n);
                addedge(j,i);
            }
            if(min(t[i],t[j])>max(t[i]-d[i],t[j]-d[j]))
            {
                addedge(i+n,j);
                addedge(j+n,i);
            }
        }
    }
}
int main()
{
    int n,x,y,u,v;
    init();
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d:%d%d:%d%d",&x,&y,&u,&v,&d[i]);
        s[i]=x*60+y;
        t[i]=u*60+v;
    }
    buildmap(n);
    solve(n);
    return 0;
}
poj3207 

说明：比较有意思的一道题，给圆上的点连线，那么两个点之间的线两种可能圆内或圆外，然后可以根据几何关系枚举判断每对线是否矛盾即可，可以参考下这篇博客http://blog.csdn.net/l04205613/article/details/6668318

代码：

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
    int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int a[maxn],b[maxn];
int scc,top,index;
void init()
{
    scc=top=index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
bool solve(int n)
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    for(int i=0;i<2*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<n;i++)
    {
        if(belong[i]==belong[i+n])
            return false;
    }
    return true;
}
int main()
{
    init();
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {
        scanf("%d%d",&a[i],&b[i]);
    }
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[j]>a[i]&&a[j]<b[i]&&b[j]>b[i])||(a[i]>a[j]&&b[j]>a[i]&&b[i]>b[j]))
            {
                addedge(i,j+m);
                addedge(j,i+m);
                addedge(i+m,j);
                addedge(j+m,i);
            }
        }
    }
    if(solve(m))
    {
        printf("panda is telling the truth...\n");
    }
    else
    {
        printf("the evil panda is lying again\n");
    }
    return 0;
}
poj2749

说明： N 个牛栏，现在通过一条通道（s1,s2）把他们连起来，他们之间有一些约束关系，一些牛栏不能连在同一个点，一些牛栏必须连在同一个点，现在问有没有可能把他们都连好，而且满足所有的约束关系，如果可以，输出两个牛栏之间距离最大值的最小情况。每个牛栏只能连s1或者s2，求最小化最大值，明显的二分答案，然后对于每一个mid，如果两个牛连某两个栏设为sx，sy距离大于mid，则连sx到!sy,sy到!sx。

代码：

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
    int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int x[maxn],y[maxn];
int a[maxn],b[maxn];
int ax[maxn],ay[maxn];
int bx[maxn],by[maxn];
int x1,y1,x2,y2,d;
int n,A,B;
int scc,top,index;
void init()
{
    scc=top=index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
void build(int mid)
{
	init();
	for(int i=0;i<A;i++)
	{
		addedge(ax[i],ay[i]+n);
		addedge(ay[i],ax[i]+n);
		addedge(ax[i]+n,ay[i]);
		addedge(ay[i]+n,ax[i]);
	}
	for(int i=0;i<B;i++)
	{
		addedge(bx[i],by[i]);
		addedge(by[i],bx[i]);
		addedge(bx[i]+n,by[i]+n);
		addedge(by[i]+n,bx[i]+n);
	}
	for(int i=0;i<n;i++)
	{
		for(int j=i+1;j<n;j++)
		{
			if(a[i]+a[j]>mid)
			{
				addedge(i,j+n);
				addedge(j,i+n);
			}
			if(b[i]+b[j]>mid)
			{
				addedge(i+n,j);
				addedge(j+n,i);
			}
			if(a[i]+b[j]+d>mid)
			{
				addedge(i,j);
				addedge(j+n,i+n);
			}
			if(b[i]+a[j]+d>mid)
			{
				addedge(i+n,j+n);
				addedge(j,i);
			}
		}
	}
}
bool solve(int mid)
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    memset(belong,0,sizeof(belong));
    build(mid);
    for(int i=0;i<2*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<n;i++)
    {
        if(belong[i]==belong[i+n])
            return false;
    }
    return true;
}
int main()
{
	scanf("%d%d%d",&n,&A,&B);
	scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
	for(int i=0;i<n;i++)
	{
		scanf("%d%d",&x[i],&y[i]);
		a[i]=abs(x[i]-x1)+abs(y[i]-y1);
		b[i]=abs(x[i]-x2)+abs(y[i]-y2);
	}
	d=abs(x1-x2)+abs(y1-y2);
	for(int i=0;i<A;i++)
	{
		scanf("%d%d",&ax[i],&ay[i]);
		ax[i]--,ay[i]--;
	}
	for(int i=0;i<B;i++)
	{
		scanf("%d%d",&bx[i],&by[i]);
		bx[i]--,by[i]--;
	}
	int l=1,r=8000000,ans=-1;
	while(l<=r)
	{
		int mid=(l+r)>>1;
		if(solve(mid))
		{
			ans=mid;
			r=mid-1;
		}
		else
			l=mid+1;
	}
	printf("%d\n",ans);
	return 0;
}
poj2296

说明：每个点只能在正方形的下边或上边，同样的二分答案，关于覆盖的判断比较麻烦点，具体见代码：

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
    int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
struct point{
	int x,y;
}a[1005];
int scc,top,index,n;
void init()
{
    scc=top=index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
void build(int mid)
{
	init();
	for(int i=0;i<n;i++)
	{
		for(int j=i+1;j<n;j++)
		{
			if(abs(a[i].x-a[j].x)>=mid)
				continue;
			if(a[i].y==a[j].y)
			{
				addedge(i,j+n);
				addedge(j,i+n);
				addedge(i+n,j);
				addedge(j+n,i);
			}
			else if(abs(a[i].y-a[j].y)<mid)
			{
				if(a[i].y>a[j].y)
				{
					addedge(i+n,i);
					addedge(j,j+n);
				}
				else
				{
					addedge(i,i+n);
					addedge(j+n,j);
				}
			}
			else if(abs(a[i].y-a[j].y)<2*mid)
			{
				if(a[i].y>a[j].y)
				{
					addedge(i+n,j+n);
					addedge(j,i);
				}
				else
				{
					addedge(j+n,i+n);
					addedge(i,j);
				}
			}
		}
	}
}
bool solve()
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    memset(belong,0,sizeof(belong));
    for(int i=0;i<2*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<n;i++)
    {
        if(belong[i]==belong[i+n])
            return false;
    }
    return true;
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		for(int i=0;i<n;i++)
		{
			scanf("%d%d",&a[i].x,&a[i].y);
		}
		int l=1,r=20000,ans=0;
		while(l<=r)
		{
			int mid=(l+r)>>1;
			build(mid);
			if(solve())
			{
				ans=mid;
				l=mid+1;
			}
			else
				r=mid-1;
		}
		printf("%d\n",ans);
	}
	return 0;
}
poj2723

说明:每组钥匙只能选一个，比较裸，，然后二分开门的数，每个门至少应该有一把钥匙，orz当年楼教曾经打过的比赛

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <math.h>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=4000005;
const int maxn=4505;
struct Edge{
    int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int a[maxn],b[maxn];
int x[maxn],y[maxn];
int scc,top,Index,n,m;
void init()
{
    scc=top=Index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++Index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
bool solve()
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    memset(belong,0,sizeof(belong));
    for(int i=0;i<4*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<2*n;i++)
    {
        if(belong[i]==belong[i+2*n])
            return false;
    }
    return true;
}
void build(int mid)
{
    init();
    for(int i=0;i<n;i++)
    {
        addedge(x[i],y[i]+2*n);
        addedge(y[i],x[i]+2*n);
    }
    for(int i=0;i<mid;i++)
    {
        addedge(a[i]+2*n,b[i]);
        addedge(b[i]+2*n,a[i]);
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        if(n==0&&m==0)
            break;
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&x[i],&y[i]);
        }
        for(int i=0;i<m;i++)
            scanf("%d%d",&a[i],&b[i]);
        int l=0,r=m,ans=0;
        while(l<=r)
        {
            int mid=(l+r)>>1;
            build(mid);
            if(solve())
            {
                l=mid+1;
                ans=mid;
            }
            else
            {
                r=mid-1;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}
zoj3656

说明：和poj第一道差不多，不同的是对于二进制每一位的数都判断下，最多31次2-sat

代码：

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
    int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int b[maxn][maxn];
int scc,top,Index,n;
void init()
{
    scc=top=Index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++Index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
void build()
{
    init();
    for(int i=0;i<n;i++)
    {
        for(int j=i+1;j<n;j++)
        {
            if(i&1 && j&1)
            {
                if(b[i][j]&1)
                {
                    addedge(i+n,j);
                    addedge(j+n,i);
                }
                else
                {
                    addedge(i,i+n);
                    addedge(j,j+n);
                    addedge(i+n,j+n);
                    addedge(j+n,i+n);
                }
            }
            else if(!(i&1) && !(j&1))
            {
                if(b[i][j]&1)
                {
                    addedge(i,j);
                    addedge(j,i);
                    addedge(i+n,j);
                    addedge(j+n,i);
                }
                else
                {
                    addedge(i,j+n);
                    addedge(j,i+n);
                }
            }
            else
            {
                if(b[i][j]&1)
                {
                    addedge(i,j+n);
                    addedge(j,i+n);
                    addedge(i+n,j);
                    addedge(j+n,i);
                }
                else
                {
                    addedge(i,j);
                    addedge(j,i);
                    addedge(i+n,j+n);
                    addedge(j+n,i+n);
                }
            }
            b[i][j]>>=1;
        }
    }
}
bool check()
{
    for(int i=0;i<n;i++)
    {
        for(int j=i;j<n;j++)
        {
            if(i==j)
            {
                if(b[i][i]!=0)
                    return true;
                continue;
            }
            if(b[i][j]!=b[j][i])
                return true;
        }
    }
    return false;
}
bool solve()
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    memset(belong,0,sizeof(belong));
    for(int i=0;i<2*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<n;i++)
    {
        if(belong[i]==belong[i+n])
            return false;
    }
    return true;
}
int main()
{
    while(scanf("%d",&n)==1)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                scanf("%d",&b[i][j]);
            }
        }
        if(check())
        {
            printf("NO\n");
            continue;
        }
        int flag=1;
        for(int bit=0;bit<31;bit++)
        {
            build();
            if(!solve())
            {
                flag=0;
                break;
            }
        }
        if(flag)
        {
            printf("YES\n");
        }
        else
            printf("NO\n");
    }
    return 0;
}
zoj3422

说明：这个题挺有意思，x数组的值只能是0或者1，对于每个特定的第i项x[i]只能是一个值，然后二分dep的值，根据每组c[dep]的值建图。

代码：

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=2005;
struct Edge{
    int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int a[10005],b[10005],c[10005];
int scc,top,Index,n,m;
void init()
{
    scc=top=Index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++Index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
void build(int mid)
{
    init();
    for(int i=0;i<mid;i++)
    {
        if(c[i]==0)
        {
            addedge(a[i],b[i]+n);
            addedge(b[i],a[i]+n);
        }
        else if(c[i]==1)
        {
            addedge(a[i],b[i]);
            addedge(a[i]+n,b[i]+n);
            addedge(b[i],a[i]);
            addedge(b[i]+n,a[i]+n);
        }
        else
        {
            addedge(a[i]+n,b[i]);
            addedge(b[i]+n,a[i]);
        }
    }
}
bool solve()
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    memset(belong,0,sizeof(belong));
    for(int i=0;i<2*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<n;i++)
    {
        if(belong[i]==belong[i+n])
            return false;
    }
    return true;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a[i],&b[i],&c[i]);
        }
        int l=0,r=m,ans=0;
        while(l<=r)
        {
            int mid=(l+r)>>1;
            build(mid);
            if(solve())
            {
                ans=mid;
                l=mid+1;
            }
            else
                r=mid-1;
        }
        printf("%d\n",ans);
    }
    return 0;
}
hdu4115

说明:也是很有意思的题，剪刀石头布，由于这个人不能输，那么他肯定只能出和另一个人一样或者取胜，这就是2-sat的两种选择，然后要求的条件连边建图即可。

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=12005;
struct Edge{
    int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int a[maxn],b[maxn];
int scc,top,Index,n,m;
void init()
{
    scc=top=Index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++Index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
bool solve()
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    memset(belong,0,sizeof(belong));
    for(int i=0;i<2*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<n;i++)
    {
        if(belong[i]==belong[i+n])
            return false;
    }
    return true;
}
int main()
{
    int t,cnt=0;
    scanf("%d",&t);
    while(t--)
    {
        init();
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++)
        {
            int x;
            scanf("%d",&x);
            b[i]=x;
            if(x==1) a[i]=2;
            else if(x==2) a[i]=3;
            else a[i]=1;
        }
        for(int i=0;i<m;i++)
        {
            int u,v,c;
            scanf("%d%d%d",&u,&v,&c);
            u--,v--;
            if(c==1)     //not same
            {
                if(a[u]==a[v])
                {
                    addedge(u,v+n);
                    addedge(v,u+n);
                    addedge(u+n,v);
                    addedge(v+n,u);
                }
                if(a[u]==b[v])
                {
                    addedge(u,v);
                    addedge(v+n,u+n);
                }
                if(b[u]==a[v])
                {
                    addedge(u+n,v+n);
                    addedge(v,u);
                }
            }
            else
            {
                if(a[u]!=a[v])
                {
                    addedge(u,v+n);
                    addedge(v,u+n);
                    addedge(u+n,v);
                    addedge(v+n,u);
                }
                if(a[u]!=b[v])
                {
                    addedge(u,v);
                    addedge(v+n,u+n);
                }
                if(b[u]!=a[v])
                {
                    addedge(u+n,v+n);
                    addedge(v,u);
                }
            }
        }
        printf("Case #%d: ",++cnt);
        if(solve())
            printf("yes\n");
        else
            printf("no\n");
    }
    return 0;
}
zoj3717

说明：比较明显的2-sat，二分mid，根据mid连边判断

代码：

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <math.h>
using namespace std;
typedef long long LL;
#define INF 0x7fffffff
const double eqs=1e-8;
const int maxm=2000005;
const int maxn=505;
struct Edge{
    int to,next;
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn];
int Stack[maxn];
int belong[maxn];
int num[maxn];
bool instack[maxn];
int scc,top,Index,n,m;
struct point{
    double x,y,z;
}a[maxn];
double dis[maxn][maxn];
void init()
{
    scc=top=Index=tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void tarjan(int u)
{
    int v;
    dfn[u]=low[u]=++Index;
    Stack[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
bool solve()
{
    memset(dfn,0,sizeof(dfn));
    memset(instack,false,sizeof(instack));
    memset(num,0,sizeof(num));
    memset(belong,0,sizeof(belong));
    for(int i=0;i<2*n;i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    for(int i=0;i<n;i++)
    {
        if(belong[i]==belong[i+n])
            return false;
    }
    return true;
}
void build(double mid)
{
    init();
    for(int i=0;i<n;i++)
    {
        for(int j=i+1;j<n;j++)
        {
            if(dis[i][j]<mid)
            {
                addedge(i,j+n);
                addedge(j,i+n);
            }
            if(dis[i+n][j]<mid)
            {
                addedge(i+n,j+n);
                addedge(j,i);
            }
            if(dis[i][j+n]<mid)
            {
                addedge(i,j);
                addedge(j+n,i+n);
            }
            if(dis[i+n][j+n]<mid)
            {
                addedge(i+n,j);
                addedge(j+n,i);
            }
        }
    }
}
int main()
{
    while(scanf("%d",&n)==1)
    {
        for(int i=0;i<n;i++)
        {
            scanf("%lf%lf%lf",&a[i].x,&a[i].y,&a[i].z);
            scanf("%lf%lf%lf",&a[i+n].x,&a[i+n].y,&a[i+n].z);
        }
        memset(dis,0,sizeof(dis));
        double l=0,r=0,ans=0;
        for(int i=0;i<2*n;i++)
        {
            for(int j=i+1;j<2*n;j++)
            {
                dis[i][j]=dis[j][i]=sqrt((a[i].x-a[j].x)*(a[i].x-a[j].x)+(a[i].y-a[j].y)*(a[i].y-a[j].y)+(a[i].z-a[j].z)*(a[i].z-a[j].z));
                r=max(dis[i][j],r);
            }
        }
        while(l+eqs<r)
        {
            double mid=(l+r)/2;
            build(mid);
            if(solve())
            {
                ans=mid;
                l=mid;
            }
            else
                r=mid;
        }
        ans/=2;
        printf("%.3lf\n",ans-0.0005);
    }
    return 0;
}

通过这几道题，不难发现，解决2-sat问题的关键主要是找到那些两两只能选一个的元素，然后建图的时候牢牢记住根据矛盾关系选xxxx就必须选oooo，而且2-sat一般有不少二分答案判断是否可行的题，值得注意。





neko01
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
每天一篇javascript学习小结（RegExp对象）
11-25
var text = "cat, bat, sat, fat"; var pattern = /.at/; if (pattern.test(text)){ alert("The pattern was matched."); } 2、正则的toString()方法 var pattern = new RegExp("\\[bc\\]at", "gi");...
2-sat 小结
人生如戏
10-25 136
定义 简略的说， nnn 个变量 aia_iai​，且 ai∈[0,1]a_i\in[0,1]ai​∈[0,1]。 给出一些条件，形式如下： aia_iai​ opopop aj=0/1(op∈[and,or,xor])a_j =0/1(op\in[and,or,xor])aj​=0/1(op∈[and,or,xor]) 求解 2−SAT2-SAT2−SAT 即找到一组合法的 aaa 满足所有限...
（转）2-SAT小结
weixin_30496751的博客
09-05 80
2-sat小结 原文作者：老K 原文传送门 2-sat是什么 一类问题是这样的： （两个符号的意思 \(\lor \ or,\land \ and\)） 有n个布尔变量，现在对它们做出限制，比如\(a_i=1,a_i \lor a_j=1\)，求一组可行的解。 假设限制元素最多的限制限制了k个元素，这个问题就被称为k-sat问题。 可以证明（然而我不会），\(k>2\)时是NP...
2-SAT 小结
weixin_30363817的博客
09-11 86
　　PS：今天（2014.10.27）准备PPT，明天在组合数学课上与大家一起分享一下2-SAT。我以为是一件简单的事情。但是，当我看了自己这篇博客以后，发现居然还是不懂。很多资料不全，也没仔细讲。整理了一下，又修改了。尽量让自己下次再看到这博客的时候，一遍下来就能懂。虽然引用了别人的博客，我尽量讲得不需要进入别人的博客就能看懂。 　　一些这方面的内容写得很好的博客。（排列是随机的。可...
[学习笔记]2-SAT 小结
aigongshi8561的博客
02-04 118
目录 2-SAT 小结 2-SAT 小结 从SAT说起 布尔可满足性问题（Boolean satisfiability problem；SAT)）属于决定性问题，也是第一个被证明属于NP完全的问题。 此问题在计算机科学上许多领域的皆相当重要，包括计算机科学基础理论、算法、人工智能、硬件设计等等。---摘...
2-SAT算法小结
a_forever_dream的博客
05-14 801
定义 SAT 是 Satisfiability 的简称，一般记作 k−SATk-SATk−SAT 即 k−k-k−适应性 问题。 由于当 k>2k>2k>2 时是个NPC问题，所以只考虑 k=2k=2k=2 ，即 2−SAT2-SAT2−SAT 问题。 一般来说，就是有若干个位置，每个位置 aia_iai​ 的状态为 0/10/10/1 中的一种，然后有若干个限制，每个限制形如 ai∗aj=0/1a_i*a_j=0/1ai​∗aj​=0/1，其中 ∗*∗ 可以是 and,or,xora
2-SAT(小结)
qq_43653111的博客
09-02 119
学习目标： 2-SAT(小结) 这个人讲的很好，我就不详细讲了 学习内容： 注意点 1.适用范围：x1&x2=0,问给出 m 个关系表达式后，能否给这 n 个变量找出一个赋值的方法，使得满足所有的表达式； 2.对于每个变量都只有两种取值：0 / 1，那么对于每个点，我们把每个变量拆成 true 点和 false 点； 3.要注意只有关系明确的时候才能建边； 其中一个不成立则另一个一定成立（这是明确的关系）； 4.无解的情况：某一个变量的 false 能走到 true，从 true 也能走到 fals
2-SAT问题的小结
WZZ66631的博客
03-28 117
简介 　　什么是2-SAT呢？就是有一些集合，每个集合中有且仅有两个元素，且不能同时选取两个元素，集合间的元素存在一定的选择关系，求解可行性及可行方案。 算法 1、连边 2、跑tarjan 3、判可行性，即同一集合中的两个点是否同属一个强连通块 4、缩点建新图，连反边 5、拓扑序，若当前点没有被访问过，则选择该点，不选择其另外的点 连边 2-SAT算法本身并不难，关键是...
2-SAT 问题与解法小结
weixin_30693683的博客
03-18 204
这个算法十分的奇妙qwq... 将一类判定问题转换为图论问题，然后就很容易解决了。 本文有一些地方摘录了一下赵爽《2-SAT解法浅析》 （侵删） 一些概念 \(SAT\)问题：就是给一些布尔变量赋值，使得所有给你的条件成立的问题---适定性(Satisfiability)问题。我们令\(k\)为所有条件中含有变量的最大值，那么我们就可以称其为\(k-SAT\)问题。 可以证明\(k>2...
[2-sat]小结
Gzb1128的栖息地
03-16 153
因为一直不怎么会这个东西，所以今天整理一下这个东西的内容。 原来这个东西这么简单的吗。2sat里面一条边x-&gt;y表示x选了之后y必须选，只要建出满足这种条件的边之后跑tarjan就可以知道到底有没有解了。因此x &amp;^| y这种布尔运算就可以试一试 x在取某个值时y会不会强制取值，会的话就连边就行了，然后tarjan一下，看一看 x和!x是否在同一个联通块里，如果都没有的话就说明有一...
独立主格结构小结.pdf
12-05
2. 名词/代词+现在分词：现在分词表示逻辑主语正在进行的动作或与主句同时发生的情况，例如"He stood silent in the moon-light, his door open." 中的"his door open"表明门是开着的状态。 3. 名词/代词+过去分词...
英语过去完成时用法小结.pdf
12-10
2. 描述过去连续发生的多个动作时，通常用一般过去时，如"He entered the room, turned on the light and sat down at the table." 这些动作依次发生，没有强调先后顺序。 3. 在表达过去的愿望、打算、计划等未能...
JavaScript中各种引用类型的常用操作方法小结_.docx
10-09
- **splice(index, deleteCount, item1, item2, ...)**：`splice`方法功能强大，它可以删除、插入或替换数组中的元素。参数`index`指定开始位置，`deleteCount`表示要删除的元素个数，后面的参数则是要插入的元素。 ...
参考资料-三极管要点.zip
01-17
它由两个PN结组成，分为NPN型和PNP型，根据结构的不同，可以作为放大器或开关使用。 二、工作模式 1. 放大模式：在适当的偏置电压下，三极管能够将微小的基极电流放大为较大的集电极电流，实现电流放大作用，这是...
[课题设计]SSM框架开发个人通讯录+jsp+Java前后端分离带论文和源码.zip
07-20
本项目是一个基于SSM框架开发的个人通讯录应用，采用JSP作为前端技术，实现了前后端分离。项目针对计算机相关专业的学生以及需要进行项目实战练习的Java学习者，提供了完整的源码、数据库脚本和开发说明，同时附带论文参考，可作为毕业设计或课程设计的优质资源。 在功能方面，该项目实现了基本的通讯录增删改查功能，用户可以通过前端界面录入、修改和查询联系人信息，后台则通过SSM框架进行数据处理和业务逻辑的实现。此外，项目还支持分页显示功能，提高了用户体验。 技术层面，项目采用了成熟的SSM框架进行开发，确保了代码的结构清晰、易于维护。数据库选用MySQL，稳定可靠，且易于扩展。开发环境包括JDK、IDEA和Tomcat，配置简单，便于上手。 经过严格的调试，项目已确保可稳定运行。对于有一定基础的Java学习者，还可以在此基础上进行功能拓展，进一步提升实战能力。
物联网工程_基于定点室内消毒物联网机器人设计.docx
07-20
物联网工程_基于定点室内消毒物联网机器人设计
C语言-水仙花数代码实现
最新发布
07-20
c语言，C语言--水仙花数，代码实现
计算机科学与技术_基于微信小程序的电影推荐系统的设计与实现.docx
07-20
计算机科学与技术_基于微信小程序的电影推荐系统的设计与实现

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值