main.java

设存在集合A

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package binaryrelations;

import java.util.*;
import java.io.*;

/**
 *
 * @author Administrator
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
        int An=1,Am=1;
        boolean Find1=false,Find2=false;
        ArrayList<Elements>    A =new ArrayList<Elements>();     //定义集合A
        ArrayList<OrderedPair> R =new ArrayList<OrderedPair>();  //R是A上的关系
        BufferedReader readStream=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("准备输入集合的元素，输入exit结束输入");
        again1:
        while(true){
            System.out.print("请输入集合的第"+An+"个元素：");
            Elements a=new Elements();
            a.name=readStream.readLine();
            if(a.name.equals("exit")){
                System.out.println("输入结束");
                break;
            }
             for(Elements s :A){
                 if(s.equals(a)){
                     System.out.println("集合中有相同的元素,请重新输入");
                     continue again1;
                 }
            }
            A.add(a);
            An++;
        }
       An--;
       System.out.print("集合A中的元素是：\n{");
       for(Elements s :A){
           System.out.print(s.name+",");
       }
       System.out.println("}");
       System.out.println("输入/随机生成的二元关系?  I/R");
       String str=readStream.readLine();
       if(str.equals("I")){
           again:
           while(true){
            System.out.println("请输入集合的第"+Am+"个二元关系：");
            Find1=false;
            Find2=false;
            System.out.print("请输入FirstElement：(输入exit结束输入)");
            Elements a=new Elements();
            a.name=readStream.readLine();
            if(a.name.equals("exit")){
                System.out.println("输入结束");
                break;
            }
            System.out.print("请输入SecondElement：");
            Elements  b=new Elements();
            b.name=readStream.readLine();            
            for(Elements s :A){
                 if(s.name.equals(a.name))Find1=true;
                 if(s.name.equals(b.name))Find2=true;
                 }
            if(!Find1||!Find2){
                     System.out.println("集合中没有输入的元素,请重新输入");
                     continue again;
             }
            OrderedPair ordereda=new OrderedPair(a,b);
            for(OrderedPair ordereds :R){
                 if(ordereds.equals(ordereda)){
                     System.out.println("有相同的二元关系,请重新输入");
                     continue again;
                 }
            }
            R.add(ordereda);
            Am++;
           }
           Am--;
       }
       else{        
       Random r=new Random();
       int num=r.nextInt(An*An);
       again2:
       for(int j=0;j<=num;j++){
           OrderedPair ordereda=new OrderedPair(A.get(r.nextInt(An)),A.get(r.nextInt(An)));
           for(OrderedPair ordereds :R){
                 if(ordereds.equals(ordereda)){
                     continue again2;
                 }
            }
            R.add(ordereda);
       }
       }
       System.out.print("生成的二元关系：\n{");
       for(OrderedPair ordereds :R){
           System.out.print("("+ordereds.FirstElement.name+","+ordereds.SecondElement.name+"),");
       }
       System.out.println("}");
       new Main().ClosureComputing(A,R);
    }
    public void ClosureComputing(ArrayList<Elements> A,ArrayList<OrderedPair> R) {
        final int N=50;
        boolean array[][]=new boolean [N][N];                     //新建一个关系矩阵
        int ii=0,jj=0;
        ArrayList<OrderedPair> rR =new ArrayList<OrderedPair>();  //R的自反闭包
        ArrayList<OrderedPair> sR =new ArrayList<OrderedPair>();  //R的对称闭包
        ArrayList<OrderedPair> tR =new ArrayList<OrderedPair>();  //R的传递闭包
        boolean Flag=true;                        //等价的标志
        int AssembleN=A.size();
        rR=(ArrayList<OrderedPair>) R.clone();      //生成自反闭包
        again3:
        for(int i=0;i<AssembleN;i++){                
           OrderedPair ordereda=new OrderedPair(A.get(i),A.get(i));
           for(OrderedPair orderedr :R){
               if(orderedr.equals(ordereda)){
                   continue again3;
                 }
            }
           rR.add(ordereda);
           Flag=false;
        }
        sR=(ArrayList<OrderedPair>) R.clone();      //生成对称闭包
        again4:
        for(OrderedPair ordereds :R){
            OrderedPair ordereda=new OrderedPair(ordereds.SecondElement,ordereds.FirstElement);
            for(OrderedPair orderedsr :sR){
                if(orderedsr.equals(ordereda)){
                    continue again4;
                }
            }
            sR.add(ordereda);
            Flag=false;
        }
        for(OrderedPair ordereds :R){            //将关系转换成矩阵
            for(int i=0;i<AssembleN;i++){
                if(A.get(i).equals(ordereds.FirstElement))ii=i;
                if(A.get(i).equals(ordereds.SecondElement))jj=i;
            }
            array[ii][jj]=true;
        }
        System.out.println("关系矩阵:");
        for(int i=0;i<AssembleN;i++){
            for(int j=0;j<AssembleN;j++){
                System.out.print((array[i][j]?1:0)+" ");
            }
            System.out.print("\n");
        }
        for (int k = 0; k < N; k++) {
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) { 
                    if(array[i][k] && array[k][j]) {
                        if(!array[i][j])Flag=false;
                         array[i][j] = true; 
                    } 
                } 
            } 
        }
        for(int i=0;i<AssembleN;i++){
            for(int j=0;j<AssembleN;j++){
                if(array[i][j]){
                    OrderedPair ordereda=new OrderedPair(A.get(i),A.get(j));
                    tR.add(ordereda);
                }
            }
        }
        System.out.println("R"+(Flag?"是":"不是")+"等价关系");
        System.out.print("R的自反闭包rR：\n{");
        for(OrderedPair ordereds :rR){
            System.out.print("("+ordereds.FirstElement.name+","+ordereds.SecondElement.name+"),");
        }
        System.out.println("}"); 
        System.out.print("R的对称闭包sR：\n{");
        for(OrderedPair ordereds :sR){
            System.out.print("("+ordereds.FirstElement.name+","+ordereds.SecondElement.name+"),");
        }
        System.out.println("}");
        System.out.print("R的传递闭包tR：\n{");
        for(OrderedPair ordereds :tR){
            System.out.print("("+ordereds.FirstElement.name+","+ordereds.SecondElement.name+"),");
        }
        System.out.println("}");
    }
}