算法-矩阵快速幂-爬楼梯问题-栈和队列-

矩阵快速幂

使用场景

一个问题可转化为求解一个矩阵的n次方的形式；
一个递推形式：

爬楼梯问题

需求
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

案例
输入：n = 2 输出：2 分析两种情况：1+1 ；2
输入：n = 3 输出：3 分析三种情况：1+1 +1；1+ 2 ； 2+1

矩阵快速幂

class Solution {
    public int climbStairs(int n) {
        // 矩阵快速幂
        int[][] w = {{1,1},{1,0}};
        
        // 结果矩阵
        int[][] ret = pow(w,n);
        return ret[0][0];
    }

    public int[][] pow(int[][] a,int n){
        int[][] ret = {{1,0},{0,1}};
        while(n > 0){
            if((n & 1 ) == 1)
                ret = multiply(ret,a);
            n >>= 1;
            a = multiply(a,a);
        }
        return ret;
    }

    public int[][] multiply(int[][] a,int[][] b){
        int[][] c = {{0,0},{0,0}};
        for(int i = 0; i < 2; i ++){
            for(int j = 0 ; j < 2; j++){
                c[i][j] = a[i][0]*b[0][j] + a[i][1]*b[1][j];
            }
        }
        return c;
    }
}

动态规划

栈和队列

栈解决常用方法

方法	说明
boolean empty()	测试此堆栈是否为空
E peek()	查看堆栈顶部的对象，而不从堆栈中删除它
E pop()	删除此堆栈顶部的对象，并将该对象作为此函数的值返回
E push(E item)	将项目推送到此堆栈的顶部
int search(Object c)	返回一个对象在此堆栈上的基于1的位置

LinkedList解决常用方法

offer09 用两个栈实现队列

需求
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。
(若队列中没有元素，deleteHead 操作返回 -1 )

案例
第一行： [“CQueue”,“appendTail”,“deleteHead”,“deleteHead”] 表示操作
CQueue 构造队列 appendTail 队尾入队 deleteHead 队头出队
第二行： [[],[3],[],[]] 表示入队的数字 (只有appendTail操作有对应值)
第三行输出：[null,null,3,-1]
构造队列和入队 返回 null；出队返回 数字 或者 -1；

两个stack实现

class CQueue {
    //声明两个栈
    Stack<Integer> A;
    Stack<Integer> B;

    public CQueue() {
        // 给声明的两个栈赋值
        A = new Stack<Integer>();
        B = new Stack<Integer>();
    }
    
    public void appendTail(int value) {
        A.push(value);
    }
    
    public int deleteHead() {
        // 将A栈内容放入B栈中，A是数组尾部 操作
        while(!A.empty())
            B.push(A.pop());
            // 将栈A的内容全部放入栈B中
        // B是数组头部 操作
        int result = B.empty()?-1:B.pop();
        // 更新A栈内容
        while(!B.empty())
            A.push(B.pop());
        return result;
    }
}

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue obj = new CQueue();
 * obj.appendTail(value);
 * int param_2 = obj.deleteHead();
 */

使用LinkedList

class CQueue {
    // 创建链表 LinkedList
    LinkedList<Integer> llist;
    public CQueue() {
        llist = new LinkedList<Integer>();
    }
    
    public void appendTail(int value) {
        // 队列的尾部插入元素
        llist.addLast(value);
    }
    
    public int deleteHead() {
        // 队列的头部删除元素
        return llist.size() == 0 ? -1 : llist.removeFirst();
    }
}

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue obj = new CQueue();
 * obj.appendTail(value);
 * int param_2 = obj.deleteHead();
 */

offer30 包含min函数的栈

需求
定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

分析
要求min、push 及 pop 的时间复杂度都是 O(1)。
那么不能在min方法中实施遍历，必须在push和pop的时候处理。

示例

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.

LinkedList方式

class MinStack {
    // 使用链表
    // 存储正常插入的元素
    LinkedList<Integer> A; 
    // 用于保存最小值
    int min = Integer.MAX_VALUE;
    // 用于存储元素 从小到大的顺序
    LinkedList<Integer> Min;

    /** initialize your data structure here. */
    public MinStack() {
    	// 创建两个链表
        A = new LinkedList<Integer>();
        Min = new LinkedList<Integer>();
    }
    // 链表中插入元素
    public void push(int x) {
    	// 新元素放在链表的尾部
        A.addLast(x);
        // 新元素放入有序链表。（非严格有序）
        if(x <= min){
            min = x;
            Min.addFirst(min);
        } 
        else{
            Min.addLast(x);
        }
           
    }
    // 删除链表最后一个添加的元素。
    public void pop() {
        int a = A.removeLast();
        while(a == min){
            Min.removeFirst();
            min = Min.getFirst();
        }
    }
    // 返回链表最后一个元素。
    public int top() {
        return A.getLast();
    }
    // 返回当前链表中最小的元素。
    public int min() {
        return min;
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.min();
 */

Stack实现

class MinStack {

    // 使用stack实现。
    Stack<Integer> A,B;
    /** initialize your data structure here. */
    public MinStack() {
        A = new Stack<Integer>();
        B = new Stack<Integer>();
    }

    
    public void push(int x) {
        A.push(x);
        // 刚开始B肯定是空的，则! B.empty()为假 走的是else。
        if(! B.empty() && B.peek() <= x){
            // B栈添加的是 栈顶元素  栈顶元素小于要添加的元素
            B.push(B.peek());
        }else{
            B.push(x);
        }
    }
    // 栈出栈
    public void pop() {
        A.pop();
        B.pop();
    }
    // 查看栈顶的元素
    public int top() {
        return A.peek();
    }
    // 查看栈中的最小值。
    public int min() {
        return B.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.min();
 */