SWUST OJ题解

SWUST OJ 3:A BUG

一句话题解：简单种类并查集

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define N 2010

int flag;
int n,m;
int f[N];
int w[N];

int Find(int x)
{
    if(x!=f[x]) f[x]=Find(f[x]);
    return f[x];
}
void UN(int x,int y)
{
    x=Find(x);
    y=Find(y);
    if(x>y) f[x]=y;
    if(x<y) f[y]=x;
}
int main()
{
    int T,iCase=1;
    scanf("%d",&T);
    while(T--){
        flag=0;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++){
            f[i]=i;
            w[i]=0;
        }
        while(m--){
            int a,b;
            scanf("%d%d",&a,&b);
            if(!w[a] && !w[b]){
                w[a]=b;
                w[b]=a;
            }
            else if(w[a] && !w[b]){
                w[b]=a;
                UN(b,w[a]);
            }
            else if(!w[a] && w[b]){
                w[a]=b;
                UN(a,w[b]);
            }
            else if(w[a] && w[b]){
                if(Find(a)==Find(b)) flag=1;
                else{
                    UN(a,w[b]);
                    UN(b,w[a]);
                }
            }
        }
        printf("Scenario #%d:\n",iCase++);
        if(flag)
            printf("Suspicious bugs found!\n");
        else
            printf("No suspicious bugs found!\n");
    }
    return 0;
}

SWUST OJ 334:神奇的数字

思路：字符串处理，用C++11的stoi转化string为int类型即可，很方便

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int main()
{
	int i,j;
	string x,y;
	string a;
	cin>>a;
	for(i=0;i<a.length();i++)
	{
		if(a[i]!='|')
		{
			x+=a[i];
		}
		else break;
	}
	for(j=i+1;j<a.length();j++)
	{
	    y+=a[j];
	}
	sort(x.begin(),x.end());
	sort(y.begin(),y.end());
	int x1=stoi(x);
	int y1=stoi(y);
	int sum=x1+y1;
	cout<<sum<<endl;
}

SWUST OJ 1011:二叉排序树的实现和查找

思路：先创建create，然后search查找，理解BST就很简单，可以看看算法笔记或者大话数据结构的概念很容易入门！
二叉排序树的左子树要小于等于根节点，右子树要大于等于根节点，左右子树又是BST，我们每次只能对二叉树的左右子树的一个进行递归遍历

/****二叉排序树BST****/
#include<iostream>
const int maxn=100;
using namespace std;
int n,sum;
int a[maxn];
struct node
{
	int data;
	struct node*lc;
	struct node*rc;
};
//插入 
void  insert(node* &root,int x)
{
	if(root==NULL)//空树 
	{
		root=new node;
		root->data=x;
		root->lc=root->rc=NULL;//这一步不能忘记，必须左右子树为NULL，不然无法进行下一步创建节点
		return; 
	}
	if(root->data==x)
	{
		return;
	}
	else if(x<root->data)
	{
		insert(root->lc,x);
	}
	else
	{
		insert(root->rc,x);
	}
} 
//创建
node* create(int a[],int n)
{
	node* root=NULL;
	for(int i=0;i<n;i++)
	{
		insert(root,a[i]);
	 } 
	 return root;
 } 
void serach(node* root,int m)
{
 if(root==NULL)
{
 	sum=-1;
 	return;
}
if(root->data==m)
{
	sum++;
}	
else if(root->data>m)
{
	sum++;
	serach(root->lc,m);
}
else
{
	sum++;
	serach(root->rc,m);
}
}
int main()
{
	node* root;
	int n;
	cin>>n;
	for(int i=0;i<n;i++)
	cin>>a[i];
	int m;
	cin>>m;
	root=create(a,n);
	serach(root,m);
	cout<<sum;
}

SWUST OJ 1015:堆排序算法

思路：貌似只是建立一个小根堆，没有涉及到一趟堆排序

#include<iostream>
#include<algorithm>
using namespace std;
int head[100],n;
void downhead(int low,int high)
{
	int i=low,j=i*2;
	while(j<=high)
	{
		if(j+1<=high&&head[j+1]<head[j])
		{
			j=j+1;
		}
		if(head[i]>head[j])
		{
			swap(head[i],head[j]);
			i=j;
			j=i*2;
		}
		else
		{
			break;
		}
	}
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>head[i];
	}
	for(int i=n/2;i>=1;i--)
	{
		downhead(i,n);//创建堆 
	}
	/*for(int i=n;i>1;i--)
	{
		swap(head[i],head[1]);
		downhead(1,i-1);
        break;
	}*/
	for(int i=1;i<=n;i++)
	{
		cout<<head[i]<<" ";
	}
}

SWUST OJ 1242:考研崽儿

一句话题解：错排问题，网上搜一下，简单递归实现就行,数据开到long long

#include<iostream>//错排问题 
using namespace std;
long long f(int m)
{ 
	if(m==1)  return 0;
	if(m==2)  return 1;
	else 
	{
	return (m-1)*(f(m-2)+f(m-1));
    }
}
int main()
{
	int n,m;
	cin>>n;
	while(n--)
	{
		cin>>m;
		cout<<f(m)<<endl;
	}
}