LeetCode 1447. 最简分数题解

1447. 最简分数题解

题目来源：1447. 最简分数

2022.02.10 每日一题

本题大意是求解最简分数，即判断两个数字是否有非 1 的公因数

如果没有则 $i/j$ 是最简分数，反之则不是

有以下几种常见的求解公因数的方法

1. 辗转相除法：辗转相除法是求两个自然数的最大公约数的一种方法，也叫欧几里德算法。
2. 更相减损法：也叫更相减损术，是出自《九章算术》的一种求最大公约数的算法，它原本是为约分而设计的，但它适用于任何需要求最大公约数的场合。
3. Stein算法：由J. Stein 1961年提出，这个方法也是计算两个数的最大公约数。和欧几里德算法算法不同的是，Stein算法只有整数的移位和加减法

具体代码如下：

• 辗转相除法

  class Solution {
  public:
      vector<string> simplifiedFractions(int n) {
          vector<string> res;
          for (int i = 1; i < n; i++) {
              for (int j = i + 1; j <= n; j++) {
                  if (gcd(i, j) == 1) {
                      res.emplace_back(to_string(j) + "/" + to_string(i));
                  }
              }
          }
          return res;
      }
  
      // 辗转相除法
      int gcd(int a, int b) {
          return b == 0 ? a : gcd(b, a % b);
      }
  };
  

  class Solution {
      public List<String> simplifiedFractions(int n) {
          List<String> res = new ArrayList<>();
          for (int i = 1; i < n; i++) {
              for (int j = i + 1; j <= n; j++) {
                  if (gcd(i, j) == 1) {
                      res.add(i + "/" + j);
                  }
              }
          }
          return res;
      }
  
      // 辗转相除法
      public int gcd(int a, int b) {
          return b == 0 ? a : gcd(a, a % b);
      }
  }
  

• 更相减损法

  class Solution {
  public:
      vector<string> simplifiedFractions(int n) {
          vector<string> res;
          for (int i = 1; i < n; i++) {
              for (int j = i + 1; j <= n; j++) {
                  if (gcd(i, j) == 1) {
                      res.emplace_back(to_string(i) + "/" + to_string(j));
                  }
              }
          }
          return res;
      }
  
      // 更相减损法
      int gcd(int a, int b) {
          if (a == b)
              return a;
          return gcd(min(a, b), max(a, b) - min(a, b));
      }
  };
  

  class Solution {
      public List<String> simplifiedFractions(int n) {
          List<String> res = new ArrayList<>();
          for (int i = 1; i < n; i++) {
              for (int j = i + 1; j <= n; j++) {
                  if (gcd(i, j) == 1) {
                      res.add(i + "/" + j);
                  }
              }
          }
          return res;
      }
  
  	// 更相减损法
      public int gcd(int a, int b) {
          if (a == b)
              return a;
          return gcd(Math.min(a, b), Math.max(a, b) - Math.min(a, b));
      }
  }
  

• Stein算法

  具体操作

  Stein算法：

  设置A1=A、B1=B和C1=1

  1、如果An=0，Bn*Cn是最大公约数，算法结束

  2、如果Bn=0，An*Cn是最大公约数，算法结束

  3、如果An和Bn都是偶数，则An+1=An/2，Bn+1=Bn/2，Cn+1=Cn*2(注意，乘2只要把整数左移一位即可，除2只要把整数右移一位即可)

  4、如果An是偶数，Bn不是偶数，则An+1=An/2，Bn+1=Bn，Cn+1=Cn (很显然啦，2不是奇数的约数)

  5、如果Bn是偶数，An不是偶数，则Bn+1=Bn/2，An+1=An，Cn+1=Cn (很显然啦，2不是奇数的约数)

  6、如果An和Bn都不是偶数，则An+1=|An-Bn|，Bn+1=min(An,Bn)，Cn+1=Cn

  7、n加1，转步骤1

  来源：https://baike.baidu.com/item/%E6%9C%80%E5%A4%A7%E5%85%AC%E7%BA%A6%E6%95%B0/869308

  class Solution {
  public:
      vector<string> simplifiedFractions(int n) {
          vector<string> res;
          for (int i = 1; i < n; i++) {
              for (int j = i + 1; j <= n; j++) {
                  if (gcd(i, j) == 1) {
                      res.emplace_back(to_string(i) + "/" + to_string(j));
                  }
              }
          }
          return res;
      }
      
  	// Stein算法
      int gcd(int a, int b) {
          if (a == 0 || b == 0)
              return max(a, b);
          if (a % 2 == 0 && b % 2 == 0)
              return 2 * gcd(a >> 1, b >> 1);
          if (a % 2 == 0)
              return gcd(a >> 1, b);
          if (b % 2 == 0)
              return gcd(a, b >> 1);
          return gcd(abs(a - b), min(a, b));
      }
  };
  

  class Solution {
      public List<String> simplifiedFractions(int n) {
          List<String> res = new ArrayList<>();
          for (int i = 1; i < n; i++) {
              for (int j = i + 1; j <= n; j++) {
                  if (gcd(i, j) == 1) {
                      res.add(i + "/" + j);
                  }
              }
          }
          return res;
      }
  
      // Stein算法
      int gcd(int a, int b) {
          if (a == 0 || b == 0)
              return max(a, b);
          if (a % 2 == 0 && b % 2 == 0)
              return 2 * gcd(a >> 1, b >> 1);
          if (a % 2 == 0)
              return gcd(a >> 1, b);
          if (b % 2 == 0)
              return gcd(a, b >> 1);
          return gcd(abs(a - b), min(a, b));
      }
  }
  

最后恭喜柚子完成4A！