【刷题笔记】第六天

今天再练一道迭代搜索的题 + 力扣每日一题

Power Calculus

题目描述

给你一个整数n，可以乘或者除，可以使用中间结果，求最少运算多少次可以得到$x^n$

分析

相当于求从整数1开始，可以加或者减，可以使用中间结果，最少运算多少次可以得到n

实现细节见代码

#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstdio>
using namespace std;

const int N = 1010; 
int n;
int ans[N]; // 保存中间结果，n最大为1000，每次运算加1，也就需要1000次，所以最多运算1000次，也就是说中间结果最多有1000个
int pos; // 标记当前运算的位置
int depth; // 最大深度

// dep：当前递归深度
bool dfs(int dep) {
	if (dep > depth) return false;
	if (ans[pos] << (depth - dep) < n) {
		// depth - dep是还剩的递归次数
        // 估价函数：用最快的倍增都不能到达n，退出
        // 最快的倍增：假设ans[pos] = m, 下一层递归2m，再下一层4m， 8m 。。。 ,以2的幂倍增
		return false;
	}
	if (ans[pos] == n) {
		return true;
	}
	pos++;
	for (int i = 0; i < pos; ++i) {
		// 讨论上一个中间结果与前面所有的中间结果相加
		ans[pos] = ans[pos - 1] + ans[i];
		if (dfs(dep + 1)) {
			// 继续下一层的递归
			return true;
		}
		// 讨论上一个中间结果与前面所有的中间结果相减
		ans[pos] = ans[pos - 1] - ans[i];
		if (dfs(dep + 1)) {
			return true;
		}
	}
	pos--; // 回溯
	return false;
}

int main() {
	while (scanf("%d", &n)) {
		if (n == 0) break;
		depth = 0;
		pos = 0;
		ans[pos] = 1;
		while (!dfs(0)) {
			depth++;
		}
		printf("%d\n", depth);
	}
	return 0;
}

706. 设计哈希映射

方法一：纯数组

class MyHashMap {
    private static final int MAX_N = 1000001;
    int[] map;
    public MyHashMap() {
        map = new int[MAX_N];
        Arrays.fill(map, -1);
    }
    
    public void put(int key, int value) {
        map[key] = value;
    }
    
    public int get(int key) {
        return map[key];
    }
    
    public void remove(int key) {
        map[key] = -1;

    }
}

/**
 * Your MyHashMap object will be instantiated and called as such:
 * MyHashMap obj = new MyHashMap();
 * obj.put(key,value);
 * int param_2 = obj.get(key);
 * obj.remove(key);
 */

方法二：数组加链表

class MyHashMap {

    static class Node {
        int key, value;
        Node next;
        Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }
    public Node[] table = new Node[(int)Math.pow(2, 14)];
    public MyHashMap() {

    }

    public int getIndex(int key) {
        int hash = Integer.hashCode(key);
        hash = hash ^ (hash >>> 16);
        return hash & (table.length - 1);
    }
    
    public void put(int key, int value) {
        int index = getIndex(key);
        if (table[index] == null) {
            table[index] = new Node(key, value);
        } else {
            Node cur = table[index];
            Node pre = null;
            while (cur != null) {
                if (cur.key == key) {
                    cur.value = value;
                    return;
                }
                pre = cur;
                cur = cur.next;
            }
            Node node = new Node(key, value);
            pre.next = node;
        }
    }
    
    public int get(int key) {
        int index = getIndex(key);
        if (table[index] != null) {
            Node cur = table[index];
            while (cur != null) {
                if (cur.key == key) {
                    return cur.value;
                }
                cur = cur.next;
            }
        }
        return -1;
    }
    
    public void remove(int key) {
        int index = getIndex(key);
        if (table[index] != null) {
            Node pre = null;
            Node cur = table[index];
            while (cur != null) {
                if (cur.key == key) {
                    if (pre == null) {
                        table[index] = cur.next;
                    } else {
                        pre.next = cur.next;
                    }
                    return;
                }
                pre = cur;
                cur = cur.next;
            }
        }
    }
}