【全程NOIP计划】图论算法

【全程NOIP计划】图论算法

最短路算法

常用的最短路算法SPFA,Dijkstra,Floyd算法

最短路问题,就是对于有权图的两个点,找到一条连接两个点的路径,使得路径的权值和最小

在说最短路算法之前,必须了解松弛的概念

其实n简单,如果\(a \rightarrow b+b \rightarrow c\)的距离比\(a \rightarrow c\)的小,那么就可以用前者代替a到c的距离

各种各样 最短路实际上就是不断做松弛操作

Floyd

可以求出图中任意两点的最短路,过程很简单

首先枚举松弛操作的中间点,再枚举松弛的左右两个点,然后做松弛操作

由于Floyd算法暴力枚举的特性,所以用邻接矩阵很方便

很显然,复杂度为\(O(n^3)\)

for(int k=1;k<=n;k++)
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            a[i][j]=min(a[i][j],a[i][k]+a[k][j]);
正确性

怎么证明正确性?

对于任意两个点之间的最短路,假设有m个节点那么m一定小于n,因为重复经过同样的点没有意义(除非有负环,但是如果有负环最短路就没有意义,因为可以通过刷负环来刷最短路)

那么这m个点在外层循环都会被枚举一次,接着内层的两重循环一定会枚举到这个点在最短路上相邻的两个点

这个点被松弛之后,我们就可以认为它已经不在最短路上了,因为此时的\(a \rightarrow b \rightarrow c\)\(a \rightarrow c\)是一样的

外层循环做完之后,两个点之间的所有m个点也都被消除完了,这两个点的距离就是最短路

易错点

有一个易错点,就是三个循环的顺序不要搞错了

先枚举中间,再枚举两边

因为,如果左边先枚举,那么n次循环之后,松弛的点对都是从左边出发的,如果没有恰好沿着路径的顺序去枚举中间的点,就无法松弛整条路径

有一个神奇的结论,只要Floyd整个过程连续做三遍,不管三个循环是什么顺序,跑出来的结果都是对的,但是不建议使用,主要是慢啊

作用

裸的最短路实际上用的不多,用到了也很简单,基本上是看做一个工具来用

Floyd实际上还可以处理除了最短路以外其他的问题

P2419 Cow Contest S

思路

拓扑排序可以,但是Floyd也可以

这样点很少,边很多的图就很适合使用Floyd

如果用\(e[i][j]\)表示能不能推出i<j的关系,如果\(e[i][k]=1且e[k][j]=1\),那么\(e[i][j]=1\)

这样我们就可以处理出任意两点间的大小关系,有或者没有

然后如果对于一个点,我们能确定剩下所有点和它的大小关系

那么这个点的排名就被确定了

如果一个点,对于其他任何一个点都能推出它的关系,然后它的排名就确定了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
int n,m;
int e[105][105];
void floyd()
{
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                e[i][j]|=(e[i][k]&e[k][j]);//用floyd来解决直接的关系 
}
int main()
{
    cin>>n>>m;
    int l,r;
    while(m--)
    {
        cin>>l>>r;
        e[l][r]=1;
    }
    floyd();
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        int mark=1;
        for(int j=1;j<=n;j++)
            if(j!=i&&e[j][i]==0&&e[i][j]==0)//如果有谁不能确定 
            {
                mark=0;
                break;
            }
        cnt+=mark;
    }
    cout<<cnt<<endl;
    return 0;
}

P2888 Cow Hurdles S

思路

让我想到了营救那道题目

实际上就是二分答案加判断

但是用Floyd处理dp关系可以更简单的做这个题目

\(e[i][j]\)表示从i到j经过的路径中,最小的最大栏杆高度

容易得到类似于Floyd的关系

也就是说如果走\(i \rightarrow k \rightarrow j\)的路线,那么栏杆的最大高度为\(max(e[i][k],e[k][j])\)

如果这个最大值小于\(i \rightarrow j\)之间的最大值,那么就可以更新这个最小的最大值

也就是先用\(O(n^3)\)来处理一个Floyd,然后再用\(O(t)\)处理答案

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
const int INF=0x3f3f3f3f;
const int maxn=305;
int n,m,T;
int a[maxn][maxn];
int main()
{
	memset(a,20,sizeof(a));
	cin>>n>>m>>T;
	for(int i=1;i<=m;i++)
	{
		int s,e,h;
		cin>>s>>e>>h;
		a[s][e]=h;
	}
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
			a[i][j]=min(a[i][j],max(a[i][k],a[k][j]));
	while(T--)
	{
		int l,r;
		cin>>l>>r;
		if(a[l][r]!=336860180)
		cout<<a[l][r]<<'\n';
		else
		cout<<-1<<'\n';
	}
	return 0;
}

P2047 社交网络

思路

这道题目和前两道题目差不多,只不过除了求i到j的路径数量,还要求i经过k到j的路径数量

最短路径比较好求,如果\(e[i][k]和e[k][j]\)更新了\(e[i][j]\)的话,让\(cnt[i][j]=cnt[i][k]*cnt[k][j]\)就可以了

如果\(e[i][k]+e[k][j]=e[i][j]\)那么还要让\(cnt[i][j]+=cnt[i][k]*cnt[k][j]\)

因为数据量过小,所以这样来表示是可以的,主要运用的是乘法原理

题目个每个点求\(\sum_{s!=v,t!=v}c(s,t,v)c(s,t)\)

那么就先跑Floyd,然后枚举每个点,再枚举s和t,用\(cnt[s][v]*cnt[v][t]/cnt[s][t]\)计算就可以了

void floyd()
{
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            {
                if(e[i][k]+e[k][j]<e[i][j])
                {
                    e[i][j]=e[i][k]+e[k][j];
                    cnt[i][j]=cnt[i][k]*cnt[k][j];
                }
                else if(e[i][j]+e[k][j]==e[i][j])
                {
                    cnt[i][j]+=cnt[i][k]*cnt[k][j];
                }
            }
}
int main()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
            e[i][j]=INF;
        e[i][i]=0;
    }
    int l,r,v;
    while(m-->0)
    {
        cin>>l>>r>>v;
        e[l][r]=v;
        e[r][l]=v;
        cnt[l][r]=1;
        cnt[r][l]=1;
    }
    floyd();
    for(int k=1;k<=n;k++)
    {
        double ans=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(cnt[i][j]&&e[i][k]+e[k][j]==e[i][j])
                    ans+=(double)(cnt[i][k]*cnt[k][j]/cnt[i][j]);
        printf("%.3lf",ans);
    }
}

Bellman-Ford

这是一个单源最短路算法

也就是能求出从某个点出发到剩下所有点的最短路

这个算法用\(dis[v]\)表示从s到v的距离

算法总共进行n-1轮,每轮枚举所有的边u到v,来做s到u到u的松弛操作

不难理解,第一轮会求出和s间距一条边的最短路,第二轮会求出间距小于等于2条边的最短路,第n-1轮回求出间距小于等于n-1条边的最短路

由于最短路最多有n-1条边,所以n-1轮之后每个点都求到了真正的最短路

显然这个算法的复杂度是\(O(NM)\)的,n是点数,m是边数

显然这个算法适合直接结构体来存边,也就是边表

void bellman_ford()
{
    for(int i=1;i<=n;i++)
        dis[i]=INF;
    dis[s]=0;
    for(int k=1;k<n;k++)
    {
        for(int i=1;i<=ecnt;i++)
            if(dis[e[i].x]+e[i].v<dis[e[i].y])
                dis[e[i].y]=dis[e[i].x]+e[i].v;
    }
}

SPFA

上面的一个算法有一个优化,实际上就是spfa

我们每轮操作其实并不一定要把所有的边都松弛一遍

因为有一些店在上一轮之后最短路并没有发生变化,那么从这个点出发的边做松弛也一定没有变化

所以我们不再枚举n-1轮,而是用一个队列,表示刚刚发生过变化,准备要进行松弛的点

每次从队列里拿出一个点,然后枚举这个点的出边并进行松弛,如果出点的值边了,就把出点也加入队列

一个进一步的优化用\(flag[v]\)表示点v是否在队列里,如果已经在了,那显然是不用重复进队的

显然一开始就应该把s放进队列,然后从s开始松弛

也是用邻接链表来村边

void spfa()
{
    for(int i=1;i<=n;i++)
        flag[i]=false;
    for(int i=1;i<=n;i++)
        dis[i]=INF;
    dis[s]=0;
    q[++head]=s;
    for( ;tail<=head; ++tail)
    {
        flag[q[tail]]=0;
        for(int i=1)
    }
}
复杂度

时间复杂度为\(O(VE)\),有的时候并不比Bellman-Ford更快

作用

但是spfa并不是一无是处,当图中有负环的时候,Dijkstra这种纯粹求最短路的算法就挂了

因为负环实际上意味着图中没有最短路

而spfa有三种方式来判断是否存在负环:

1.用\(cnt[v]\)来表示从s到v的最短路经过了多少个点,如果u到v送出了s到v,那么就让\(cnt[v]\)更新为\(cnt[u]+1\),之前提到过,一个正常的最短路不应该有超过n个点的,因此当\(cnt[v]>n\)的时候有内鬼,终止交易

2.统计进队次数,一个点如果入队大于n次

3.dfs班也很简单,如果一个点被松弛了,就直接递归进这个点去松弛别人就可以了。如果一个点递归了一圈又回到自己了,显然有负环。一般第二种方法比第一种方法快一点,而第三种方法比前两种都要快。spfa判负环只能判有没有,不能找哪里,如果要找哪里,要用tarjan算法

P3199 最小圈

思路

问题实际上是求\(C=\sum w[i]/k\),其中i是边,\(w[i]\)是边权,k是边数

问题显然存在二分单调性,也就是如果答案太大,那么不符合最小的要求,但是一定可以找出来一个圈,使得比值小于等于这个答案,如果答案太小,那么一定找不到一个圈,使得比值满足这个答案

那么就可以二分答案ans,如果不存在\(\sum w[i]/k \le ans\),则答案小,否则答案大

把这个式子变一下,就得到\(\sum w[i]-k*ans=\sum(w[i]-ans) \le 0\)

需要注意,负圈不一定是要每条边都小于0,而是只要权值和小于0的就可以刷最短路

所以满足\(\sum(w[i]-ans)\le 0\)的圈实际上就是一个负圈,因为答案是浮点数,所以$<0和 \le0 $的区别不大

那么枚举出答案ans后给每个边权都减去ans,然后spfa判负环就可以了

这个实际上是一个01分数规划的过程

复杂度上线为\(O(nmlogw)\),比较危险

Dijkstra

只要出现单源最短路一定要卡spfa的今天,单源最短路的最佳解法就是Dijkstra

实际上如果用stl的优先队列来写,Dijkstra也不会比spfa复杂到哪里去

Dijkstra其实就是一个堆优化的spfa

spfa每次是从已经准备要松弛别人的点中选出某一个,而Dijkstra则是直接使用优先队列贪心地从中选出dis最小的那个

至于这个贪心的全局最优的证明,可以使用归纳法严格证明

每条边至多被访问一次,所以每个点的松弛次数不会超过边数

所以Dijkstra的时间复杂度为\(O(MlogN)\)

另一种理解

Dijkstra的思路其实是每次从dis中挑出dis最短的那个,之前没有被挑过的点出来松弛

Dijkstra实际上有一个\(O(nm)\)的做法,就是直接用for循环去找这个最短的的点,这也是为什么会有堆优化的Dijkstra的这种说法

本质上是用堆来维护dis数组的,但是要注意

不能直接对dis建堆,然后随着松弛操作改堆里的数据

如果直接改堆的数据,会破坏堆的结构,导致堆不能完成它应有的功能

因此还要没松弛一次就把出点入堆,然后出堆的时候去更新dis

void dijkstra()
{
    for(int i=1;i<=n;i++)
        dis[i]=INF;
    dis[s]=0;
    size=0;
    push((nod){x,0});
    while(size)
    {
        while(size&&heap[1].y>dis[heap[1].x]) pop();
        if(!size) break;
        x=heap[1].x;
        dis[x]=heap[1].y;
        pop();
        for(int i=link[x];i;i=e[i].next)
            if(dis[x]+e[i].v<dis[e[i].y])
            {
                dis[e[i].y]=dis[x]+e[i].v;
                push((node){e[i].y,dis[e[i].y]});
            }
    }
}

P2837 Milk Pumping G

思路

这个题看上去有二分单调性,又涉及到分数,似乎是分数规划

实际上并没有这么复杂,因为n很小,流量的上线也很小

所以直接枚举路径的流量,流量确定之后最大化流量/花费,实际上就是最小化花费

于是就可以跑Dijkstra,要求流量大于等于枚举的流量的边才能参与松弛就行了

int dijkstra(int y)
{
    for(int i=1;i<=n;i++)
        dis[i]=INF;
    dis[1]=0;
    size=0;
    push((nod){1,0});
    while(size)
    {
        while(size&&heap[1].y>dis[heap[1].x]) pop();
        if(!size) break;
        x=heap[1].x;
        dis[x]=heap[1].y;
        pop();
        for(int i=link[x];i;i=e[i].next)
            if(e[i].w>=y&&dis[x]+e[i].v<dis[e[i].y])
            {
                dis[e[i].y]=dis[x]+e[i].v;
                push((node){e[i].y,dis[e[i].y]});
            }
    }
    return dis[n];
}
int main()
{
    ……
    dounble ans=0;
    for(int i=1;i<=1000;i++)
        ans=max(ans,(double)i/dij(i));
    printf("%lld\n",(long long)(ans*1e6));
    ……
}

最短路建模

差分约束

差分约束系统就是给你一堆变量,然后给你一堆形如\(a_i-a_j \le c\)的不等式

像这样两个变量相减的形式就叫做差分,一堆变量相减就是差分系统

差分约束能告诉你差分系统中,任意两个变量最多是多少,或者是最少是多少

做法

如果有a1-a2<=b,a2-a3<=d,a1-a3<=e

假设要求a1-a3的范围,我们发现除了a1-a3<=e的条件之外,还有a1-a2+a2-a3=a1-a3<=b+d

那么如果b+d<=e,a1-a3就<=b+d,否则a1-a3<=e

发现了没,这个操作和最短路的松弛操作特别像

我们用\(e[i][j]\)来表示\(a_i-a_j\le e[i][j]\),那么不难发现,对于一个中间点k,我们有\(e[i][j]=min(e[i]][j],e[i][k]+e[k][j])\),于是我们就用一个最短路的模型表示一个差分约束系统,然后就可以用最短路算法解出想要的变量的差分关系

有的人就会问,如果同时出现左边右边符号颠倒的情况怎么办,一般就可以把符号和两个数的位置变化一下,一般不会出现变化不了的情况

还有一种题型就是判断有没有解,我们要考虑什么情况下无解,情况有很多,但是可以转化为一个情况,就是a-b<=c且a-b>=d而且c<d,可以看成c-d<0,这就意味着一条循环约束出现了负环,如果常规差分约束建完图之后有负环,那么就无解了

模板代码

#include <iostream>#include <cstdio>#include <algorithm>#include <cstring>#include <string>#include <queue>#define int long long using namespace std;const int maxn=50005;struct edge{	int e,next,val;}ed[maxn*2];int en,first[maxn];void add_edge(int s,int e,int val){	en++;	ed[en].next=first[s];	first[s]=en;	ed[en].e=e;	ed[en].val=val;}int n,m;int d[maxn],num[maxn];bool vis[maxn];queue <int> q;bool spfa(int x){	d[x]=0;	q.push(x); 	vis[x]=true;	num[x]++;	while(q.size())	{		int x=q.front();		q.pop();		vis[x]=false;		for(int i=first[x];i;i=ed[i].next)		{			int e=ed[i].e,val=ed[i].val;			if(d[e]>d[x]+val)			{				d[e]=d[x]+val;				if(!vis[e])				{					q.push(e);					vis[e]=true;					num[e]++;					if(num[e]==n+1)					return false;				}			}		}	}	return true; }signed main(){	cin>>n>>m;	for(int i=1;i<=n;i++)	d[i]=2147483647;	for(int i=1;i<=m;i++)	{		int x,y,z;		cin>>x>>y>>z;		add_edge(y,x,z);	}	for(int i=1;i<=n;i++)	add_edge(n+1,i,0);	if(!spfa(n+1))	{		cout<<"NO"<<'\n';		goto end;	}	for(int i=1;i<=n;i++)	cout<<d[i]<<" ";	end: ;	return 0;}

P1993 小k的农场

思路

直接差分约束系统,判断是否有解就可以了

#include <iostream>#include <cstdio>#include <algorithm>#include <cstring>#include <string>#include <queue>#define int long long using namespace std;const int maxn=50005;struct edge{	int e,next,val;}ed[maxn*2];int en,first[maxn];void add_edge(int s,int e,int val){	en++;	ed[en].next=first[s];	first[s]=en;	ed[en].e=e;	ed[en].val=val;}int n,m;int d[maxn],num[maxn];bool vis[maxn];queue <int> q;bool spfa(int x){	d[x]=0;	q.push(x); 	vis[x]=true;	num[x]++;	while(q.size())	{		int x=q.front();		q.pop();		vis[x]=false;		for(int i=first[x];i;i=ed[i].next)		{			int e=ed[i].e,val=ed[i].val;			if(d[e]>d[x]+val)			{				d[e]=d[x]+val;				if(!vis[e])				{					q.push(e);					vis[e]=true;					num[e]++;					if(num[e]==n+1)					return false;				}			}		}	}	return true; }signed main(){	cin>>n>>m;	memset(d,0x3f,sizeof(d));	for(int i=1;i<=m;i++)	{		int op;		cin>>op;		if(op==1)		{			int a,b,c;			cin>>a>>b>>c;			add_edge(a,b,-c);		}		else if(op==2)		{			int a,b,c;			cin>>a>>b>>c;			add_edge(b,a,c);		}		else		{			int a,b;			cin>>a>>b;			add_edge(a,b,0);			add_edge(b,a,0);		}	}	for(int i=1;i<=n;i++)	add_edge(n+1,i,0);	if(!spfa(n+1))	{		cout<<"No"<<'\n';		return 0;	}	cout<<"Yes"<<'\n';	return 0;}

P3275 糖果

思路

跟上一道题目一样差不多,处理一下差分约束系统

a不比b少就是a>=b

a比b少怎么办?

实际上就是a<b等价于a<=b-1

于是a比b少表示为b-a>=1

现在约束能建了,问题是要求总数最小

可以建立一个抽象节点,表示0颗糖的基准线

然后抽象点往所有点约束为1的边,表示每人至少分一颗糖

这里需要注意,由于求的是最小值,约束是a-b>=c,因此这里求的是最长路,要找出最大的那个下限

最后所有人dis就是不得不满足的下限,然后就能得到答案了

传递闭包

传递闭包的数学概念比较抽象,不太好懂,但是做出来很简单

简单说就是,两个关系i-->k和k-->j可以复合出一个新关系i-->j,这就是传递性

给你一个集合,集合里定义了一个关系i-->j,再定义一个关系i-->j,满足:

1.对于所有满足i-->j,使得i能通过-->的复合关系连接到j,但是不满足i-->j

2.除此之外不存在i和j,使得i能通过-->的复合关系链接到j,但是不满足i-->j

精简版说法,就是传递闭包是关系的极大生成集,因为

1.如果a是b的祖先,那么a肯定是b的父母的父母的父母的……

2.不存在如果a是b父母的父母的父母的……,我们就不能称a为b的祖先的情况

实际上还是有点难理解,但是直接看怎么做吧

对于一个邻接矩阵e,\(e[i][j]=0\)不满足关系i-->j,\(e[i][j]=1\)表示满足关系i-->j

然后我们对e做与操作的Floyd,也就是松弛操作为\(e[i][j]=e[i][k] and[k][j]\)

就这?对,我们之前实际上遇到了一个差不多的例题

强连通分量

强连通分量指的是图的一个极大的子图,满足图内任意两点内任意两点之间可以相互到达

需要注意的是,强连通分量的概念是针对有向图的,无向图没有强连通分量的说法,因为对于无向图,只要是一个连通图就能任意互相到达

强连通分量分成两个部分第一个是任意两个点可以相互到达,这个比较好理解

比如完全图,也就是任意两个点都连接两个方向的边

再比如一个有向环,也满足这个条件

而极大的子图就是说,再加入原图中的任意一个点以及这个点的边到这个子图内,都不能满足互相到达的条件

比如一个完全图子完全图,虽然能互相到达,但是不是极大的

Tarjan算法

求一个图的强连通分量一般用tarjan算法,这里的tarjan算法只指dfs树,也就是dfn-low的那一套理论

首先对于任意一个有向图,我们显然可以用dfs来遍历整个图,每个点只经过一次,并不用管所有点都经过没,那么按照dfs递归的关系,把遍历过程画出来,就是一个dfs树

tarjan在dfs树的基础上定义了dfn和low的概念

dfn就是dfs过程被访问到的顺序

而low表示的是这个点能到达的所有点中,dfn最小的点

tarjan算法首先用一个栈按顺序记录dfs遍历过的点,同时计算dfn和low,每当发现一个点的dfn等于low,那么就把这个点以及栈中之后的所有点弹出来,作为一个强连通分量

void tarjan(int x,int fa){    vis[x]=true;    dfn[x]=low[x]=++dfs_cnt;    s[++top]=x;    for(int i=link[x];i;i=e[i].next)    {        if(!dfn[e[i].y])        {            tarjan(e[i].y,x);            low[x]=min(low[x],low[e[i].y]);        }        else if(vis[e[i].y])            low[x]=min(low[x],dfn[e[i].y]);    }    if(dfn[x]==low[x])    {        grouP_cnt++;        int temp;        do{            temp=s[top--];            group[temp]=group_cnt;            vis[temp]=false;        }while(temp!=x)    }}
正确性

为什么 ?

对于子图的一个点,如果这个点可以到达任意一个点,而任意一个点也可以到达这个点,我们就说这个子图是任意两点互相到达的

在tarjan算法中,这个点就是dfn等于low的点

我们注意到,在tarjan算法中,这个点就是dfn等于low的点

我们注意到,在tarjan算法中,只要\(dfn[x]=low[x]\),那么x就会被弹出来,因此对于一个点x的子树中的点y,只有两种情况:要么已经被弹出来了,要么\(low[y]=low[x]\)

不可能\(low[y]<low[x]\),因为x可以到y,所以y能到的x也能到,那么应该\(low[x]\le low[y]\)才对

而如果\(low[y]>low[x]\),那么到回溯到\(low[y]\)对应的那个点的时候,y就被弹出栈了

所以栈里面留下来的也一定都能到达x

同时显然x也能到达它的子节点们

因此当\(dfn[x]=low[x]\)的时候,我们就说x的子树内任意互达

同时这些子树上的点往上最多只能到达x,到不了子树外面的点

因此把任意子树外的点加进来,都会破坏任意互达的条件

再来看为\(dfn[y]=low[y]\)而被提前弹出栈的的y的子树的点

这些碘同样往外最多只能到达y,到达不了x,因此把y子树中的点加进来也不能满足任意互达的条件

所以tarjan算法找到的点的集合,当然也包括这些点之间的边的集合,是强联通分量

P2341 最受欢迎的牛

思路

我们发现对于一个强联通分量内的牛的机会是相同的,要么一起当明星,要么都当不了明星

因为团体内的任意一头牛会爱慕别的牛,如果团体外的所有牛都爱它,那么就会传递到剩下的所有牛的身上

因此我们可以先做tarjan缩点,把一个强连通分量的牛看成一个整体来考虑

原来牛之间的边要转化为团体间的边

这是我们发现,缩点之后的图变成了一个DAG

前面我们提到过,环是强连通分量,因此如果图中还有环,显然还可以继续缩点

因此把所有强连通分量都缩完的图一定是一个DAG

如果整个DAG只有一个点的出度为n,那么显然所有的点都可以到达这个点

所以当我们缩完点之后发现DAG中只有一个点出度为0,那么我们说这个点中的所有的奶牛都可以当明星

posted @ 2021-11-19 15:21  wweiyi  阅读(56)  评论(0编辑  收藏  举报
js脚本