数据库：求F=A→B,B→A,B→C,A→C,C→A,最小（极小）函数依赖集合

Posted 2023-04-22

坐等学霸

利用分解规则，将所有的函数依赖变成右边都是单个属性的函数依赖。从题目来看，F中的任何一个函数依赖的右部仅含有一个属性：A→B，B→A，B→C，A→C，C→A

第二步去冗余的的顺序不同，产生结果也会不同，故最小函数依赖集合不止一个，还可发现另一个最小（极小）函数依赖集合为：A→B，B→A，A→C，C→A

给定一个数集A，假设其中的元素为x。现对A中的元素x施加对应法则f，记作f（x），得到另一数集B。假设B中的元素为y。则y与x之间的等量关系可以用y=f（x）表示。函数概念含有三个要素：定义域A、值域C和对应法则f。其中核心是对应法则f，它是函数关系的本质特征。

扩展资料：

函数的对应法则通常用解析式表示，但大量的函数关系是无法用解析式表示的，可以用图像、表格及其他形式表示。

函数与不等式和方程存在联系（初等函数）。令函数值等于零，从几何角度看，对应的自变量的值就是图像与X轴的交点的横坐标；从代数角度看，对应的自变量是方程的解。

另外，把函数的表达式（无表达式的函数除外）中的“=”换成“<”或“>”，再把“Y”换成其它代数式，函数就变成了不等式，可以求自变量的范围。

参考资料来源：百度百科——函数

参考技术A 数据库：求F=A→B,B→A,B→C,A→C,C→A,最小（极小）函数依赖集合

要解答此问题我们先来了解一下概念：

如果函数依赖集F满足以下条件，则称F为一个极小函数依赖集。也称为最小依赖集或最小覆盖。

（1）F中任一函数依赖的右部仅含有一个属性。

（2）F中不存在这样的函数依赖X→A，使得F与F-X→A等价。

（3）F中不存在这样的函数依赖X→A，X有真子集Z使得F-X→AUZ→A与F等价。

然后我们再来看一下通用解答步骤：

① 用分解的法则，使F中的任何一个函数依赖的右部仅含有一个属性；

② 去掉多余的函数依赖：从第一个函数依赖X→Y开始将其从F中去掉，然后在剩下的函数依赖中求X的闭包X+，看X+是否包含Y，若是，则去掉X→Y；否则不能去掉，依次做下去。直到找不到冗余的函数依赖；

③ 去掉各依赖左部多余的属性。一个一个地检查函数依赖左部非单个属性的依赖。例如XY→A，若要判Y为多余的，则以X→A代替XY→A是否等价？若A属于(X)+，则Y是多余属性，可以去掉。

下面我们来解答以下楼主提出的这个问题：

1、利用分解规则，将所有的函数依赖变成右边都是单个属性的函数依赖。从题目来看，F中的任何一个函数依赖的右部仅含有一个属性：A→B,B→A,B→C,A→C,C→A，跳过第二步直接进行第三步。

2、去掉F中多余的函数依赖

（1）设A→B冗余，从F中去掉A→B,则F1=B→A,B→C,A→C,C→A。计算(A)F1+：设X(0)=A,计算X(1)：扫描F1中各个函数依赖，找到左部为A或A子集的函数依赖，A→C。故有X(1)=X(0)U C=AC;扫描F1中各个函数依赖，找到左部为AC或为AC子集的函数依赖，C→A,X(2)=X(1)U C=AC.但AC不包含B，故A->B不能从F中去掉。

（2）设B→A冗余，从F中去掉B→A，则F2=A→B,B→C,A→C,C→A。计算(B)F2+:设X(0)=B，计算X(1)：扫描F2中各个函数依赖，找到左部为B或者B子集的函数依赖，B→C.故有X(1)=X(0)U C =BC;扫描F2中各个函数依赖，找到左部为BC或为BC子集的函数依赖，C->A,X(2)=X(1)U A=ABC.X(2)包含所有属性，故B→A可从F中去掉。

（3）设B→C冗余，从F中去掉B→C，则F3=A→B,A→C,C→A。计算(B)F3+：扫描F3中各个函数依赖，找不到左部为B或B子集的函数依赖,因为找不到这样的函数依赖，故有X(1)=X(0)=B，(B)F1+= B不包含C，故B→C不是冗余的函数依赖，不能从F1中去掉。

（4）设A→C冗余，从F中去掉A→C，则F4=A→B,B→C，C→A。计算(A)F4+：设X(0)=A,计算X(1)：扫描F4中各个函数依赖，找到左部为A或A子集的函数

依赖，A→B。故有X(1)=X(0)U B=AB;扫描F4中各个函数依赖，找到左部为AB或为AB子集的函数依赖，B→C,X(2)=X(1)U C=ABC.X(2)包含所有属性，故A→C可从F中去掉。

（5）设C→A冗余，从F中去掉C→A，则F4=A→B,B→C。计算(C)F5+：设X(0)=C,计算X(1)：扫描F5中各个函数依赖，找到左部为C或C子集的函数依赖，找不到左部为C或C子集的函数依赖,因为找不到这样的函数依赖，故有X(1)=X(0)=C，(B)F1+= C不包含A，故C→A不是冗余的函数依赖，不能从F中去掉。

（6）至此，所有依赖均以验算完毕，故F最小（极小）函数依赖集合为：A→B,B→C，C→A 参考技术B 第二部去冗余的的顺序不同，产生结果也会不同，故最小函数依赖集合不止一个，还可发现另一个最小（极小）函数依赖集合为：A→B,B→A，A→C，C→A 参考技术C （3）错了，F3里面还有一个B→A没写上去

MapReduce--求哪些人两两之间是互粉好友

数据：

A:B,C,D,F,E,O B:A,C,E,K C:F,A,D,I D:A,E,F,L E:B,C,D,M,L F:A,B,C,D,E,O,M G:A,C,D,E,F H:A,C,D,E,O I:A,O J:B,O K:A,C,D L:D,E,F M:E,F,G O:A,H,I,J,K

求哪些人两两之间是互粉好友，形如：A的好友有B，B的好友有A 。 那么A和B就是互粉好友。

思路：

对每一行数据进行组合输出 （person-person，1），

然后再Reducer阶段进行统计，等于2的就是互粉好友对；

问题：将B-A转换成A-B这种形式；

方案：比较两个字符之间的大小，小的在前；

import java.io.IOException;
 
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
 
public class EachOtherFriend {
 
    public static class MyMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
        @Override
        protected void map(LongWritable key, Text value,Context context) throws IOException, InterruptedException {
            String[] lines = value.toString().split(":");
            char person = lines[0].charAt(0); 
            for (String str : lines[1].split(",")) {
                char friend = str.charAt(0);
                String per_per = "";
                if(person > friend){
                    per_per += friend+"-"+person;
                }else{
                    per_per += person+"-"+friend;
                }
                context.write(new Text(per_per), new IntWritable(1));
                
            }
        }
    }
    
    
    public static class MyReducer extends Reducer<Text, IntWritable, Text, NullWritable>{
        @Override
        protected void reduce(Text key, Iterable<IntWritable> values,Context context)
                throws IOException, InterruptedException {
            
            int num = 0;
            for (IntWritable it : values) {
                num++;
            }
            if(num > 1){
                context.write(key, null);
            }
        }
    }
    
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        
        Job job = Job.getInstance(conf);
        
        job.setJarByClass(EachOtherFriend.class);
        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReducer.class);
        
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);
        
        FileInputFormat.setInputPaths(job, new Path("G:/files/input"));
        FileOutputFormat.setOutputPath(job, new Path("G:/files/output"));
        
        boolean isDone = job.waitForCompletion(true);
        System.exit(isDone ? 0:1);
        
    }
}