该程序用一个数组id，其中每项对应一个对象，读取小于N个非负整数对序列（‘p q’，意思为对象p与对象q连通），并且打印在给出的连通对基础上还没有连通的对。定义如下属性：当且仅当p与q连通时，id[p]=id[q]。

       例如输入3 4，由于先前没有任何连通对，所以打印3 4，再输入 4 9 ，先前给出的连通对是3 4，在此基础上得不到4 9连通（即把4 9识为提供了一个新的连通），所以同样打印4 9，当再输入3 9的时候，由于前面已经给出了3 4及4 9，由可传递性可以得到3 9连通，即3 9不再是一个新的连通，故不打印。
 
public class QuickF
  {
    public static void main(String[] args)
    {
      int N = Integer.parseInt(args[0]);
      int id[] = new int[N];
      for (int i = 0; i < N ; i++) id[i] = i;
      for( In.init(); !In.empty(); )
        {
          int p = In.getInt(), q = In.getInt();
          int t = id[p];
          if (t == id[q]) continue;
          for (int i = 0;i<N;i++)
            if (id[i] == t) id[i] = id[q];
          Out.println(p+" "+q+" ");
        }
    }
  }  
 
  public class Out
  {
    public static void print(String s)
     {
 System.out.print(s);
     }
    public static void println(String s)
     {
        System.out.println(s);
     }
  }

  import java.io.*;
  public class In
  {
    private static int c;

    private static boolean blank()
      {
        return Character.isWhitespace((char) c);
      }
    private static void readC()
      {
        try
          {
            c = System.in.read();
          }
        catch (IOException e)
          {
            c = -1;
          }
      }
    public static void init()
      {
        readC();
      }
    public static boolean empty()
      {
        return c == -1;
      }
    public static String getString()
      {
        if (empty()) return null;
        String s = "";
        do
          {
            s += (char) c; readC();
          }
        while (!(empty() | blank()));
        while (!empty() && blank()) readC();
        return s;
      }
    public static int getInt()
      {
        return Integer.parseInt(getString());
      }
    public static double getDouble()
      {
        return Double.parseDouble(getString());
      }
   }