华为机试复习--数组

目录

• NC61 两数之和
• NC65 斐波那契数列
• NC73 数组中出现次数超过一半的数字
• NC37 合并区间
• NC18 顺时针旋转矩阵
• NC59 矩阵的最小路径和

NC61 两数之和

题目描述
给出一个整数数组，请在数组中找出两个加起来等于目标值的数，
你给出的函数twoSum 需要返回这两个数字的下标（index1，index2），需要满足 index1 小于index2.。注意：下标是从1开始的
假设给出的数组中只存在唯一解
例如：

给出的数组为 {20, 70, 110, 150},目标值为90
输出 index1=1, index2=2

示例1
输入
[3,2,4],6

返回值
[2,3]

#include<unordered_map>
class Solution {
public:
    /**
     * 
     * @param numbers int整型vector 
     * @param target int整型 
     * @return int整型vector
     */
//     vector<int> twoSum(vector<int>& numbers, int target) {
//         // write code here
//         vector<int> ans;
//         for(auto i=0;i<numbers.size();i++){
//             int t=target-numbers[i];
//             for(auto j=i+1;j<numbers.size();j++){
//                 if(t==numbers[j]){
//                     ans.push_back(i+1);
//                     ans.push_back(j+1);
//                     return ans;
//                 }
//             }
//         }
//         return ans;
//     }
    vector<int> twoSum(vector<int>& numbers, int target){
        vector<int> ans;
        unordered_map<int,int> ma;
        for(int i=0;i<numbers.size();i++){
            ma[numbers[i]]=i;//val--key
        }
        for(int i=0;i<numbers.size();i++){
            int t=target-numbers[i];
            if(ma.find(t)!=ma.end()&&ma.at(t)>i){
                ans={i+1,ma.at(t)+1};
                return ans;
            }
        }
        return ans;
    }
};

NC65 斐波那契数列

题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。n≤39
示例1
输入
4
返回值
3

class Solution {
public:
    int fb[45]={0};
    int Fibonacci(int n) {
        if(n==0)
            return 0;
        else if(n==1)
            return 1;
        else if(fb[n]!=0)
            return fb[n];
        else{
            fb[n]=Fibonacci(n-1)+Fibonacci(n-2);
            return Fibonacci(n-1)+Fibonacci(n-2);
        }
    }
};

NC73 数组中出现次数超过一半的数字

题目描述
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
示例1
输入
[1,2,3,2,2,2,5,4,2]

返回值
2

#include<unordered_map>
class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        unordered_map<int,int> ma;
        for(int i=0;i<numbers.size();i++){
            ma[numbers[i]]++;
            if(ma[numbers[i]]>numbers.size()/2)
                return numbers[i];
        }
        return 0;
    }
};

NC37 合并区间

题目描述
给出一组区间，请合并所有重叠的区间。
请保证合并后的区间按区间起点升序排列。
示例1
输入
[[10,30],[20,60],[80,100],[150,180]]

返回值
[[10,60],[80,100],[150,180]]

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    static bool cmp(const Interval &a,const Interval &b){
        return (a.start<b.start);
    }
    vector<Interval> merge(vector<Interval> &intervals) {
        sort(intervals.begin(),intervals.end(),cmp);//按照区间左端点大小排序
        vector<Interval> res;
        for(int i=0;i<intervals.size();){
            int l=intervals[i].start;
            int r=intervals[i].end;
            int ni=i+1;
            for(int j=i+1;j<intervals.size();j++){
                if(intervals[j].start<=r){
                    r=max(intervals[j].end,r);
                    ni=j+1;
                }
            }
            res.push_back({l,r});
            i=ni;
        }
        return res;
    }
};

NC18 顺时针旋转矩阵

题目描述

有一个NxN整数矩阵，请编写一个算法，将矩阵顺时针旋转90度。

给定一个NxN的矩阵，和矩阵的阶数N,请返回旋转后的NxN矩阵,保证N小于等于300。
示例1
输入
复制

[[1,2,3],[4,5,6],[7,8,9]],3

返回值
复制

[[7,4,1],[8,5,2],[9,6,3]]

class Solution {
public:
    vector<vector<int> > rotateMatrix(vector<vector<int> > mat, int n) {
        // write code here
        vector<vector<int>> ans=vector(n, vector<int>(n));
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                ans[i][j]=mat[n-j-1][i];
            }
        }
        return ans;
    }
};

NC59 矩阵的最小路径和

题目描述
给定一个 n * m 的矩阵 a，从左上角开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，输出所有的路径中最小的路径和。
示例1
输入
[[1,3,5,9],[8,1,3,4],[5,0,6,1],[8,8,4,0]]

返回值
12

备注:
1≤n,m≤2000
1≤arri,j≤100

class Solution {
public:
    /**
     * 
     * @param matrix int整型vector<vector<>> the matrix
     * @return int整型
     */
    int minPathSum(vector<vector<int> >& matrix) {
        // 最小路径和
        vector<vector<int>> dp=vector(2000, vector<int> (2000));
        int n=matrix.size();
        int m=matrix[0].size();
        dp[0][0]=matrix[0][0];
        for(int i=1;i<m;i++)
            dp[0][i]=dp[0][i-1]+matrix[0][i];
        for(int i=1;i<n;i++)
            dp[i][0]=dp[i-1][0]+matrix[i][0];
        for(int i=1;i<n;i++){
            for(int j=1;j<m;j++){
                dp[i][j]=min(dp[i-1][j],dp[i][j-1])+matrix[i][j];
            }
        }
        return dp[n-1][m-1];
    }
};