算法刷题_程序算法刷提u

1005/1027/1029大数简单运算

① BigInteger

• 创建赋值： BigInteger a=new BigInteger(in.readLine());
• 方法：

a.add(b);
subtract:-
multiply:*
divide:/
pow：a.pow(b)=a^b
a.gcd,abs():公约数，绝对值
mod：a.mod(b)=a%b;
//到商和余数 返回数组
System.out.println(a.divideAndRemainder(b)[1]);
compareTo方法来比较，小于则返回-1，等于则返回0，大于则返回1

BigInteger a1 = new BigInteger(“1”);
BigInteger a2 = new BigInteger(“2”);
a1.compareTo(a2);

1030 （大数）进制转换

①Integer进制转换

十进制转成十六进制：
Integer.toHexString(int i)

十进制转成八进制
Integer.toOctalString(int i)

十进制转成二进制
Integer.toBinaryString(int i)

十六进制转成十进制
Integer.valueOf(“FFFF”,16).toString()

八进制转成十进制
Integer.valueOf(“876”,8).toString()

二进制转十进制
Integer.valueOf(“0101”,2).toString()

②大数进制转换

1. BigInteger的构造函数
   BigInteger(String src)默认参数字符串为10进制数值
   BigInteger(String src, int x)
   第2个参数x是指定第一个参数src的进制类型

2. toString方法
   toString()默认把数值按10进制数值转化为字符串。
   toString(int x)把数值按参数x的进制转化为字符串。

1117大数开方

牛顿迭代法+FFT

时间复杂度为 O(n)。
(还不会）

import java.math.BigInteger;
import java.util.Arrays;

/**
 * Created by MGL on 2017/4/21.
 */
public class BigInteger_Sqrt{
    public static void main(String[] args) {
        String str = "846516548651346132456465132189465134894651645613";
        BigInteger n1 = new BigInteger(str);
        BigInteger multiply = n1.multiply(n1);
        int length = multiply.toString().length();
        System.out.println("数的长度 = " + length);
        long start = System.nanoTime();
        BigInteger sqrt = getSqrt(multiply);
        long end = System.nanoTime();
        System.out.println(end - start);
        System.out.println("对" +length +"位数进行开放运算所需要的时间 = " + (end - start)/1000000000F + "s");
        System.out.println("运算结果 = " + (sqrt.compareTo(n1) == 0));
    }

    private static BigInteger getSqrt(BigInteger num) {
        String s = num.toString();
        int mlen = s.length();    //被开方数的长度
        int len;    //开方后的长度
        BigInteger beSqrtNum = new BigInteger(s);//被开方数
        BigInteger sqrtOfNum;    //存储开方后的数
        BigInteger sqrtOfNumMul;    //开方数的平方
        String sString;//存储sArray转化后的字符串
        if (mlen % 2 == 0) len = mlen / 2;
        else len = mlen / 2 + 1;
        char[] sArray = new char[len];
        Arrays.fill(sArray, '0');//开方数初始化为0
        for (int pos = 0; pos < len; pos++) {
            //从最高开始遍历数组，
            //每一位都转化为开方数平方后刚好不大于被开方数的程度
            for (char ch = '1'; ch <= '9'; ch++) {
                sArray[pos] = ch;
                sString = String.valueOf(sArray);
                sqrtOfNum = new BigInteger(sString);
                sqrtOfNumMul = sqrtOfNum.multiply(sqrtOfNum);
                if (sqrtOfNumMul.compareTo(beSqrtNum) == 1) {
                    sArray[pos] -= 1;
                    break;
                }
            }
        }
        return new BigInteger(String.valueOf(sArray));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

1019逆序数

对象排序

class Item implements Comparable{
    int val;
    int loc;
    Item(int v,int l){
        val=v;
        loc=l;
    }
    public int compareTo(Object o) {
        return this.val - ((Item) o).getVal();
      }
    public int getVal() {
        return val;
    }
    public int getLoc() {
        return loc;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

再用Arrays.sort(arr)就可以排序了

[ATTENTION]
凡逆序对此处用树状数组解决，步骤：

• 记住 源数据obj.val 位置obj.loc
• 新建计算数组d[] 初始化为1，然后已经找到的数字变为0

• 对数据obj.val排序 从小到大找再看未排序前有几个数字 和便是逆序对的数目

  1046 A^BmodC

  二分快速幂公式（2因为b是奇数b/2少了1则加上一个1 即乘以2）
  
  代码实现
  循环次数：log2b

  long ans=1;  
      while(b>0){  
          if(b%2==1){       //如果b是奇数  
              ans=ans*a%n;  
          }     
          b=b/2;  
          a=a*a%n;  
      }  
  1
  2
  3
  4
  5
  6
  7
  8