关系规范化之求最小函数依赖集(最小覆盖)

最小函数依赖集
一、等价和覆盖
  定义:关系模式R<U,F>上的两个依赖集F和G,如果F+=G+,则称F和G是等价的,记做F≡G。若F≡G,则称G是F的一个覆盖,反之亦然。两个等价的函数依赖集在表达能力上是完全相同的。
  
二、最小函数依赖集
  定义:如果函数依赖集F满足下列条件,则称F为最小函数依赖集或最小覆盖。
  ① F中的任何一个函数依赖的右部仅含有一个属性;
  ② F中不存在这样一个函数依赖X→A,使得F与F-{X→A}等价;
  ③ F中不存在这样一个函数依赖X→A,X有真子集Z使得F-{X→A}∪{Z→A}与F等价。
  算法:计算最小函数依赖集。
  输入 一个函数依赖集
  输出 F的一个等价的最小函数依赖集G
  步骤:① 用分解的法则,使F中的任何一个函数依赖的右部仅含有一个属性;
     ② 去掉多余的函数依赖:从第一个函数依赖X→Y开始将其从F中去掉,然后在剩下的函数依赖中求X的闭包X+,看X+是否包含Y,若是,则去掉X→Y;否则不能去掉,依次做下去。直到找不到冗余的函数依赖;
     ③去掉各依赖左部多余的属性。一个一个地检查函数依赖左部非单个属性的依赖。例如XY→A,若要判Y为多余的,则以X→A代替XY→A是否等价?若A 
(X)+,则Y是多余属性,可以去掉。
  举例:已知关系模式R<U,F>,U={A,B,C,D,E,G},F={AB→C,D→EG,C→A,BE→C,BC→D,CG→BD,ACD→B,CE→AG},求F的最小函数依赖集。
  
解1:利用算法求解,使得其满足三个条件
  
① 利用分解规则,将所有的函数依赖变成右边都是单个属性的函数依赖,得F为:F={AB→C,D→E,D→G,C→A,BE→C,BC→D,CG→B,CG→D,ACD→B,CE→A,CE→G}
   
② 去掉F中多余的函数依赖
  
A.设AB→C为冗余的函数依赖,则去掉AB→C,得:F1={D→E,D→G,C→A,BE→C,BC→D,CG→B,CG→D,ACD→B,CE→A,CE→G}
  计算(AB)F1+:设X(0)=AB
  计算X(1):扫描F1中各个函数依赖,找到左部为AB或AB子集的函数依赖,因为找不到这样的函数依赖。故有X(1)=X(0)=AB,算法终止。
  (AB)F1+= AB不包含C,故AB→C不是冗余的函数依赖,不能从F1中去掉。
  
B.设CG→B为冗余的函数依赖,则去掉CG→B,得:F2={AB→C,D→E,D→G,C→A,BE→C,BC→D,CG→D,ACD→B,CE→A,CE→G}
  计算(CG)F2+:设X(0)=CG
  计算X(1):扫描F2中的各个函数依赖,找到左部为CG或CG子集的函数依赖,得到一个C→A函数依赖。故有X(1)=X(0)∪A=CGA=ACG。
  计算X(2):扫描F2中的各个函数依赖,找到左部为ACG或ACG子集的函数依赖,得到一个CG→D函数依赖。故有X(2)=X(1)∪D=ACDG。
  计算X(3):扫描F2中的各个函数依赖,找到左部为ACDG或ACDG子集的函数依赖,得到两个ACD→B和D→E函数依赖。故有X(3)=X(2)∪BE=ABCDEG,因为X(3)=U,算法终止。
  (CG)F2+=ABCDEG包含B,故CG→B是冗余的函数依赖,从F2中去掉。
  
C.设CG→D为冗余的函数依赖,则去掉CG→D,得:F3={AB→C,D→E,D→G,C→A,BE→C,BC→D,ACD→B,CE→A,CE→G}
  计算(CG)F3+:设X(0)=CG
  计算X(1):扫描F3中的各个函数依赖,找到左部为CG或CG子集的函数依赖,得到一个C→A函数依赖。故有X(1)=X(0)∪A=CGA=ACG。
  计算X(2):扫描F3中的各个函数依赖,找到左部为ACG或ACG子集的函数依赖,因为找不到这样的函数依赖。故有X(2)=X(1),算法终止。(CG)F3+=ACG。
  (CG)F3+=ACG不包含D,故CG→D不是冗余的函数依赖,不能从F3中去掉。
  
D.设CE→A为冗余的函数依赖,则去掉CE→A,得:F4={AB→C,D→E,D→G,C→A,BE→C,BC→D,CG→D,ACD→B,CE→G}
  计算(CG)F4+:设X(0)=CE
  计算X(1):扫描F4中的各个函数依赖,找到左部为CE或CE子集的函数依赖,得到一个C→A函数依赖。故有X(1)=X(0)∪A=CEA=ACE。
  计算X(2):扫描F4中的各个函数依赖,找到左部为ACE或ACE子集的函数依赖,得到一个CE→G函数依赖。故有X(2)=X(1)∪G=ACEG。
  计算X(3):扫描F4中的各个函数依赖,找到左部为ACEG或ACEG子集的函数依赖,得到一个CG→D函数依赖。故有X(3)=X(2)∪D=ACDEG。
  计算X(4):扫描F4中的各个函数依赖,找到左部为ACDEG或ACDEG子集的函数依赖,得到一个ACD→B函数依赖。故有X(4)=X(3)∪B=ABCDEG。因为X(4)=U,算法终止。
  (CE)F4+=ABCDEG包含A,故CE→A是冗余的函数依赖,从F4中去掉。
  
③ 去掉F4中各函数依赖左边多余的属性(只检查左部不是单个属性的函数依赖)由于C→A,函数依赖ACD→B中的属性A是多余的,去掉A得CD→B。
  故最小函数依赖集为:F={AB→C,D→E,D→G,C→A,BE→C,BC→D,CG→D,CD→B,CE→G}
 
  
解2:利用Armstrong公理系统的推理规则求解
  ① 假设CG→B为冗余的函数依赖,那么,从F中去掉它后能根据Armstrong公理系统的推理规则导出。
  因为CG→D (已知)
  所以CGA→AD,CGA→ACD (增广律)
  因为ACD→B (已知)
  所以CGA→B (传递律)
  因为C→A (已知)
  所以CG→B (伪传递律)
  故CG→B是冗余的。
  ② 同理可证:CE→A是多余的。
  ③ 又因C→A,可知函数依赖ACD→B中的属性A是多余的,去掉A得CD→B。

  故最小函数依赖集为:F={AB→C,D→E,D→G,C→A,BE→C,BC→D,CG→D,CD→B,CE→G}

//数据库编程实验
//求最小覆盖Fm 
//输入:属性全集U,U上的函数依赖集F
//输出:函数依赖集F的最小覆盖Fm 
#include <iostream>
#include <string>
using namespace std;

struct FunctionDependence//函数依赖 
{
	string X;//决定因素 
	string Y;	
};

void Init (FunctionDependence FD[],int n)
{
	//函数依赖关系初始化
	int i;
	string x,y;
	cout<<"请输入F中的函数依赖(决定因素在左,被决定因素在右)"<<endl; 
	//输入函数依赖集合F 
	for (i=0;i<n;i++)
	{		
		cin>>x>>y;
		FD[i].X=x;
		FD[i].Y=y;	
	} 
	cout<<"函数依赖集合"; 
	cout<<"F={" ;
	for (i=0;i<n;i++)
	{
		//显示已知的函数依赖集合F 
		cout<<FD[i].X<<"->"<<FD[i].Y;
		if (i<n-1)cout<<", ";	
	} 
	cout<<"}"<<endl; 
}
bool Match(string a,string b)//判断两个字符串是否匹配
{
	bool flag=false;
	int length1=a.length();
	int length2=b.length();
	int count=0;
	if (length1==length2)
	{
		int i=0,j=0;
		//字符串每一位是否相等 
		for (i=0;i<length1;i++)
		{
			if(a[i]==b[i])count++;
		}
		if (count==length1)
		flag=true;
	}
	return flag;
} 

string CutAndSort(string mm)//将最终得到的闭包去除其中重复的元素,并且进行排序 
{
	int size=mm.length();
	string ss="\0"; 
	int kk=0,ii=0;;
	int a[200]={0};//用来记录各个命题出现的次数
	for(kk=0;kk<size;kk++) 
	{
		a[(int)mm[kk]]++;//强制转换类型,储存各个因素的次数 
	}

	for (ii=0;ii<200;ii++)
	{
		if (a[ii]>=1)
		ss+=(char)ii;
	} 
	return ss;
} 

bool IsIn(string f,string zz)//能够判断F中决定因素f里所有的因素是否在X中,但这样可能导致结果出现重复 
{
	bool flag1=false;
	int len1=f.length();
	int len2=zz.length();
	int k=0,t=0,count1=0;
	for (k=0;k<len1;k++)
	{
		for (t=0;t<len2;t++)
		{
			if (f[k]==zz[t])
			{
				//flag1=true;break;
				count1++;
			}
		}
	}
	if (count1==len1)
	{
		flag1=true;
	}
	else flag1=false;
	return flag1;
}

string FD_Fun(FunctionDependence FD[],int n,string xx)
{

	int i;
	
	//求X关于F的闭包
	for (i=0;i<n;i++)
	{
		if (Match(FD[i].X,xx)==true)
		{
			xx+=FD[i].Y;
		}
		else if (IsIn(FD[i].X,xx)==true)
		{
			if (IsIn(FD[i].Y,xx)==false)//避免加上重复的元素 
			xx+=FD[i].Y;
		} 
	}	
	CutAndSort(xx);

	return CutAndSort(xx);
}

//从函数依赖集F中删除某个依赖关系 left->right
void  Cut(FunctionDependence FD[],int n,string left,string right,FunctionDependence Dyna[])
{	
	int i=0,j=0,count=0;
	for (i=0;i<n;i++)
	{
		if((FD[i].X==left)&&(FD[i].Y==right))
		{
		}
		else
		{
			Dyna[count].X=FD[i].X;
			Dyna[count].Y=FD[i].Y;
			count++;
		}
	}
	cout<<"\n去掉"<<left<<"->"<<right;
	cout<<"后的函数依赖集F:"<<endl;
	cout<<"F={" ; 
	for(j=0;j<count;j++)
	{
		cout<<Dyna[j].X<<"->"<<Dyna[j].Y;
		if (j<count-1)cout<<",";
	}
	cout<<"}"<<endl;	

	
}

bool RA(FunctionDependence a,FunctionDependence b)//判断冗余属性
{
	if ((IsIn(a.X,b.X)==true)&&(a.Y==b.Y)) 
	{
		return true;
	}
	else return false;
} 

void CutSameFD(FunctionDependence FD[],int n)//除去重复的函数依赖 
{
	FunctionDependence Dyna1[n+20];
	FunctionDependence Dyna2[n+20];
	FunctionDependence Dyna3[n+20];
	FunctionDependence Dyna4[n+20];
	int i=0,j=0,k=0,count=0,count1=0,count2=0;
	for (i=0;i<n;i++)
	{
			for (j=0;j<count;j++)
			{
				if((FD[i].X==FD[j].X)&&(FD[i].Y==FD[j].Y))//有函数依赖重复
				{
					break;//跳过当前的函数依赖 
				} 
			}
			if (j==count)
			{
				Dyna1[count].X=FD[i].X;
				Dyna1[count].Y=FD[i].Y;
				count++; 
			}			
	}
	cout<<"去掉重复后的函数依赖集F="<<"{";
	for (k=0;k<count;k++)
	{
		//去掉重复后的函数依赖集
		cout<< Dyna1[k].X<<"->"<<Dyna1[k].Y;
		if (k<count-1)cout<<",";
	}
	cout<<"}"<<endl;
	
	for (k=0;k<count;k++)
	{
		//从第一个函数依赖X→Y开始将其从F中去掉,
		Cut( Dyna1,count,Dyna1[k].X,Dyna1[k].Y,Dyna2);
		//然后在剩下的函数依赖中求X的闭包X+,看X+是否包含Y
		cout<<Dyna1[k].X<<"关于F的闭包:";
		cout<<FD_Fun(Dyna2,count,Dyna1[k].X);//在剩下的函数依赖中求X的闭包X+
		if(IsIn(Dyna1[k].Y,FD_Fun(Dyna2,count,Dyna1[k].X))==true)//在闭包中 
		{
			cout<<"\n"<<Dyna1[k].X<<"->"<<Dyna1[k].Y<<"冗余"<<endl;
		}
		else 
		{
			cout<<"\n"<<Dyna1[k].X<<"->"<<Dyna1[k].Y<<"不冗余"<<endl;			
			Dyna3[count1].X=Dyna1[k].X;
			Dyna3[count1].Y=Dyna1[k].Y;
			count1++;
		}
	}
	cout<<"去冗余函数依赖后的函数依赖集F={";
	for (i=0;i<count1;i++)
	{
			cout<<Dyna3[i].X<<"->"<<Dyna3[i].Y;
			if (i<count1-1)cout<<",";
	} 
	cout<<"}"<<endl;
	//去掉冗余属性
	for (i=0;i<count1;i++)
	{
		for (j=0;j<count1;j++)
		{
			if(RA(Dyna3[i],Dyna3[j])==true)
			{
				break;
			}
		}
		
			Dyna4[count2].X=Dyna3[i].X;
			Dyna4[count2].Y=Dyna3[i].Y;
			count2++;
		
	}
	//求得最小覆盖 
	cout<<endl; 
	cout<<"最小覆盖Fm="<<"{";
	for (k=0;k<count2;k++)
	{
			cout<<Dyna4[k].X<<"->"<<Dyna4[k].Y;
			if (k<count2-1)cout<<",";		
	} 
	cout<<"}"<<endl;
} 

void SingleR(FunctionDependence FD[],int n) //使F所有函数依赖的右部分解成单一属性 
{
	int lengthR=0,i=0,j=0,k=0;
	static int D=n;
	int count=0;
	FunctionDependence  DynamicFD[D+20];//建立新的空间来存储所有的函数依赖 
	cout<<"右侧属性单一化后的函数依赖集F为:"<<endl;
	cout<<"F={" ;
	for (i=0;i<n;i++)
	{
			lengthR=(FD[i].Y).size();			
			for (j=0;j<lengthR;j++)//将右部分解成单一属性,添加到属性集合的后面 
			{
				DynamicFD[count].X=FD[i].X;
				DynamicFD[count].Y= (FD[i].Y)[j];
				count++;
			}
			
	}
	for (k=0;k<count;k++)
	{
		cout<<DynamicFD[k].X<<"->"<<DynamicFD[k].Y;	
		if (k<count-1)cout<<", ";	
	}
	
	cout<<"}"<<endl; 
	D=count; 
	CutSameFD(DynamicFD,D);


}

void Fmin(FunctionDependence FD[],int n)//求最小覆盖 
{
	Init(FD,n);	
	SingleR(FD,n);	
	
}

int main()
{
	int N;
	cout<<"请输入F中函数依赖的组数:"; 
	cin>>N;
	
	FunctionDependence fd[N];
	Fmin(fd,N);
//	SingleR(fd,N);
//	CutSameFD(fd,N);
//	FD(fd,N);
	return 0;
} 
关系规范化之求最小函数依赖集(最小覆盖)_第1张图片
很后悔没有用链式结构,导致增加删除节点很麻烦,权当作为概念理解的帮助吧。



你可能感兴趣的:(关系规范化之求最小函数依赖集(最小覆盖))