校招高频题目第一章 牛客网 笔记

最新推荐文章于 2020-12-07 13:12:28 发布
最新推荐文章于 2020-12-07 13:12:28 发布
阅读量418 收藏 1
点赞数
分类专栏： 牛客网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSU_GUO_LIANG/article/details/81285547
版权

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <stack>

using namespace std;
class Solution
{
public:
    /***************************************************
    *  函数功能：判断是否为合法的括号
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-07-28-16.04
    ***************************************************/
    bool isValid(string& str)
    {
         if(str.size()<2) return false;
         int cnt=0;
         for(int i=0;i<str.size();i++)
         {
             if(str[i]!='(' && str[i]!=')')
             {
                 return false;
             }
             if(str[i]=='(')
             {
                 cnt++;
             }else if(str[i]==')' && --cnt<0)
             {
                 return false;
             }
         }
         return cnt==0;
    }
    /***************************************************
    *  函数功能：返回最长有效合法的括号子串的长度
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-07-28-16.04
    ***************************************************/
    int MaxLength(string& str)
    {
         if(str.size()<2) return 0;
         int length=str.size();
         vector<int> dp(length,0);
         int MAX=-1;
         for(int i=0;i<str.size();i++)
         {
             if(str[i]==')')
             {
                 int k=i-1-dp[i-1];
                 if(k>=0 && str[k]=='(')
                 {
                     dp[i]=dp[i-1]+2+(k>0?dp[k-1]:0);
                 }
             }
             MAX=max(MAX,dp[i]);
         }
         return MAX;
    }

};

//int main()
//{
//    string str1="((())())";
//    string str2 = "(())(()(()))";
//    string str3 = "()(()()(";
//    Solution s;
//    cout<<s.isValid(str1)<<"  length:"<<s.MaxLength(str1)<<endl;
//    cout<<s.isValid(str2)<<"  length:"<<s.MaxLength(str2)<<endl;
//    cout<<s.isValid(str3)<<"  length:"<<s.MaxLength(str3)<<endl;
//    return 0;
//}

class Solutio2
{
public:
    /***************************************************
    *  函数功能：给定一个数组，值全是正数，返回累加和为给定值K的最长子数组长度
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-07-28-17.01
    ***************************************************/
    int LongestSubarrayPositive(vector<int>& nums,int k)
    {
        if(nums.size()<1) return 0;
        int L=0;
        int R=0;
        int len=-1;
        int sum=0;
        for(int i=0;i<nums.size();i++)
        {
            while(R<nums.size() && sum<k)
            {
                sum+=nums[R++];
            }
            if(sum==k)
            {
                len=max(len,R-L);
            }
            sum-=nums[L++];
        }
        return len;
    }

    /***************************************************
    *  函数功能：给定一个数组，值可能为正，负荷0，返回累加和为给定值K的最长子数组长度
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-07-28-17.01
    ***************************************************/
    int LongestSumSubArrayLength(vector<int>& nums,int k)
    {
        if(nums.size()<1) return 0;
        map<int,int> M;
        int max_L=-1;
        int Sum=0;
        M[0]=-1;

        for(int i=0;i<nums.size();i++)
        {
            Sum+=nums[i];
            if(M.find(Sum-k)!=M.end())
            {
                max_L=max(max_L,i-M[Sum-k]);
            }
            if(M.find(Sum)==M.end())
            {
                M[Sum]=i;
            }
        }
        return max_L;
    }
    /***************************************************
    *  函数功能：给定一个数组，值可能为正，负荷0，返回累加和小于给定值K的最长子数组长度
    *  参数说明x
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O(n)
    *  题目来源  ：
    *  日期：2018-07-28-17.01
    ***************************************************/
    int LongestLessSumSubArrayLength(vector<int>& nums,int k)
    {
        if(nums.size()<1) return 0;
        map<int,int> sums;
        int length=nums.size();
        vector<int> indexs(length,0);
        indexs[length-1]=length-1;
        sums[length-1]=nums[length-1];
        for(int i=length-2;i>=0;i--)
        {
            if(nums[i]<=0)
            {
                sums[i]=sums[i+1]+nums[i];
                indexs[i]=indexs[i+1];
            }else
            {
                sums[i]=nums[i];
                indexs[i]=i;
            }
        }
        int R=0;
        int res=0;
        int sum=0;
        for(int i=0;i<length;i++)
        {
            while(R<length && sum+sums[R]<=k)
            {
                sum+=sums[R];
                R=indexs[R]+1;
            }
            sum-=R>i?nums[i]:0;
            res=max(res,R-i);
            R=max(R,i+1);
        }

        return res;
    }
};


//int main()
//{
//    int A[]={4,2,7,1,10,-1,-2,8,12,3};
//    int len=sizeof(A)/sizeof(*A);
//    vector<int> nums;
//    for(int i=0;i<len;i++)
//    {
//        nums.push_back(A[i]);
//    }
//    Solutio2 s;
//    cout<<s.LongestLessSumSubArrayLength(nums,5)<<endl;
//
//    return 0;
//}


class Solution3
{
public:
    /***************************************************
    *  函数功能：从左右两边取数游戏，返回最大值
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(2^n)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-07-28-21.22
    ***************************************************/
    int CardsInLine(vector<int>& nums)
    {
        if(nums.size()<1) return 0;
        if(nums.size()==1) return nums[0];
        if(nums.size()==2) return max(nums[0],nums[1]);
        long sum=0;
        for(int i=0;i<nums.size();i++)
        {
            sum+=nums[i];
        }
        long first=f(nums,0,nums.size()-1);
        return max(first,sum-first);
    }


private:
    int f(vector<int>& nums,int i,int j)
    {
        if(i==j)
        {
            return nums[i];
        }
        return max(nums[i]+s(nums,i+1,j),nums[j]+s(nums,i,j-1));
    }
    int s(vector<int>& nums,int i,int j)
    {
        if(i==j)
        {
            return 0;
        }
        return min(f(nums,i+1,j),f(nums,i,j-1));
    }
};

//int main()
//{
//    Solution3 s;
//    int A[]={5,14,4,11,13,10,1};
//    int len=sizeof(A)/sizeof(*A);
//    vector<int> nums;
//    for(int i=0;i<len;i++)
//    {
//        nums.push_back(A[i]);
//    }
//
//    cout<<s.CardsInLine(nums)<<endl;
//
//
//    return 0;
//}

class Solution4
{
public:
    /***************************************************
    *  函数功能：逆序栈，不使用其他数据结构
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(2^n)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-07-28-21.36
    ***************************************************/
    void ReverseStack(stack<int>& S)
    {
        if(S.empty())
        {
            return ;
        }
        int last=Reverse(S);
        ReverseStack(S);
        S.push(last);
    }
private:
    int Reverse(stack<int>& S)
    {
        int temp=S.top();
        S.pop();
        if(S.empty())
        {
            return temp;
        }else
        {
            int last=Reverse(S);
            S.push(temp);
            return last;
        }
    }
};

//int main()
//{
//    stack<int> S;
//    int A[]={5,14,4,11,13,10,1};
//    int len=sizeof(A)/sizeof(*A);
//
//    for(int i=0;i<len;i++)
//    {
//        S.push(A[i]);
//    }
//    Solution4 s;
//    s.ReverseStack(S);
//    while(!S.empty())
//    {
//        cout<<S.top()<<" ";
//        S.pop();
//    }
//    cout<<endl;
//    return 0;
//}

class Solution5
{
public:
    /***************************************************
    *  函数功能：数组小和问题
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(nlogn)，空间复杂度：O(n)
    *  题目来源  ：
    *  日期：2018-07-28-21.50
    ***************************************************/
    int SmallSum(vector<int>& nums)
    {
        if(nums.size()<2) return 0;
        return guibing(nums,0,nums.size()-1);
    }

private:
    int guibing(vector<int>& nums,int L,int R)
    {
        if(L==R)
        {
            return 0;
        }
        int mid=L+((R-L)>>1);
        return guibing(nums,L,mid)+guibing(nums,mid+1,R)+merges(nums,L,mid,R);
    }
    int merges(vector<int>& nums,int L,int mid,int R)
    {
        int i=L;
        int j=mid+1;
        vector<int> help;
        int cnt=0;
        while(i<=mid && j<=R)
        {
            if(nums[i]<=nums[j])
            {
                help.push_back(nums[i]);
                cnt+=nums[i]*(R-j+1);
                i++;
            }else
            {
                help.push_back(nums[j]);
                j++;
            }
        }
        while(i<=mid)
        {
            help.push_back(nums[i++]);
        }
        while(j<=R)
        {
            help.push_back(nums[j++]);
        }
        for(int k=0;k<help.size();k++)
        {
            nums[L+k]=help[k];
        }
        return cnt;
    }
};

//int main()
//{
//    Solution5 s;
//    int A[]={3, 1, 2, 4, 6, 2, 7, 8, 1};
//    int len=sizeof(A)/sizeof(*A);
//    vector<int> nums;
//    for(int i=0;i<len;i++)
//    {
//        nums.push_back(A[i]);
//    }
//
//    cout<<s.SmallSum(nums)<<endl;
//
//
//    return 0;
//
//
//}

class Solution6
{
public:
    /***************************************************
    *  函数功能：给定一个数组，返回子数组的最大累加和
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-07-29-17.10
    ***************************************************/
    int SubArrayMaxSum(vector<int>& nums)
    {
        if(nums.size()<1) return 0;
        int cnt=nums[0];
        int sum=0;
        for(int i=0;i<nums.size();i++)
        {
            sum+=nums[i];
            cnt=max(cnt,sum);
            sum=sum<0?0:sum;
        }
        return cnt;
    }
};

//int main()
//{
//    Solution6 s;
//    int A[]={-2, -3, -5, 0, 1, 2, -1 };
//    int len=sizeof(A)/sizeof(*A);
//    vector<int> nums;
//    for(int i=0;i<len;i++)
//    {
//        nums.push_back(A[i]);
//    }
//
//    cout<<s.SubArrayMaxSum(nums)<<endl;
//
//
//    return 0;
//
//
//}


struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};
class Solution7 {
public:
    /***************************************************
    *  函数功能：寻找倒数第K的链表值
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-07-29-17.10
    ***************************************************/
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
         if(pListHead==NULL || k<1) return NULL;
       ListNode* first=pListHead;
        ListNode* second=pListHead;
        for(int i=0;i<k-1;i++)
        {
            if(first->next!=NULL)
            {
                first=first->next;
            }else
            {
                return NULL;
            }
        }
        while(first->next!=NULL)
        {
            first=first->next;
            second=second->next;
        }
        return second;
    }
    /***************************************************
    *  函数功能：移除第K位置的链表值，并返回链表
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-07-29-17.10
    ***************************************************/
    ListNode* removeLastKthNode(ListNode* head,unsigned int k)
    {
        if(head==NULL || k<1) return head;
        ListNode* curr=head;
        int lastKth=k;
        while(curr!=NULL)
        {
            curr=curr->next;
            lastKth--;
        }
        if(lastKth>0)
        {
            return head;
        }
        if(lastKth==0)
        {
            return head->next;
        }
        curr=head;
        while(++lastKth!=0)
        {
            curr=curr->next;
        }
        curr->next=curr->next->next;
        return head;
    }

};

int main()
{
    ListNode a(1);
    ListNode b(2);
    ListNode c(3);
    ListNode d(4);
    ListNode e(5);
    a.next=&b;
    b.next=&c;
    c.next=&d;
    d.next=&e;

    Solution7 s;
    ListNode* head=NULL;
    head=s.removeLastKthNode(&a,3);
    while(head)
    {
        cout<<head->val<<" ";
        head=head->next;
    }
    return 0;
}

 

真理的追求者
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
华为校招高频选择题-1
09-03
华为校招高频选择题-1；华为校招高频选择题-1；华为校招高频选择题-1华为校招高频选择题-1；华为校招高频选择题-1；
牛客网-2017校招真题-保留最大的数
野蛮水蜜桃。
08-25 348
题目描述 给定一个十进制的正整数number，选择从里面去掉一部分数字，希望保留下来的数字组成的正整数最大。 输入描述: 输入为两行内容，第一行是正整数number，1 ≤ length(number) ≤ 50000。第二行是希望去掉的数字数量cnt 1 ≤ cnt &lt; length(number)。 输出描述: 输出保留下来的结果。 示例1 输入 复制 325 1...
校招高频数据结构与算法题目精讲
07-23
资源名称：校招高频数据结构与算法题目精讲教程内容： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
牛客--校招题
暴走的二哈
04-29 826
给定一个数组序列, 需要求选出一个区间, 使得该区间是所有区间中经过如下计算的值最大的一个： 区间中的最小数 * 区间所有数的和最后程序输出经过计算后的最大值即可，不需要输出具体的区间。如给定序列  [6 2 1]则根据上述公式, 可得到所有可以选定各个区间的计算值:   [6] = 6 * 6 = 36; [2] = 2 * 2 = 4; [1] = 1 * 1 = 1; ...
个人不熟悉的面试题目（c++，数据结构）
u012793143的博客
07-22 5701
个人不熟悉的面试题目（c++，数据结构） 整理：
高频电子线路第一章资料.ppt
05-25
高频电子线路第一章资料
高频电路基础课件：第1章 高频无源网络.pptx
05-19
高频电路基础课件：第1章 高频无源网络.pptx
高频电子线路第4章参考答案.ppt-教程与笔记习题
05-21
高频电子线路第4章参考答案.ppt
高频电路基础课件：第5章 锁相环.pptx
05-19
高频电路基础课件：第5章 锁相环.pptx
牛客网校招面试题库（附答案与解析）java篇.zip
07-26
2019【电子版】校招面试题库（附答案与解析）java篇 10牛币=10元买的 祝大家早日收到JavaWeb的Offer
牛客网优惠码-直通BAT面试算法精品课购买
u012507441的博客
05-20 1257
牛客网：https://www.nowcoder.com/9998985 可以准备面试笔试，在线提交编程，主要课程线是围绕《剑指offer》和《程序员面试金典》，对常用算法讲解不错，面试前值得一看。 专属优惠码：AIp2syb 专属优惠购课链接：http://www.nowcoder.com/courses/1?coupon=AIp2syb  直接点击优惠购课的链接就可以到    
牛客网题目分析
qq_39042331的博客
09-21 175
题目描述： 牛牛想尝试一些新的料理，每个料理需要一些不同的材料，问完成所有的料理需要准备多少种不同的材料。 输入描述： 每个输入包含 1 个测试用例。每个测试用例的第 i 行，表示完成第 i 件料理需要哪些材料，各个材料用空格隔开，输入只包含大写英文字母和空格，输入文件不超过 50 行，每一行不超过 50 个字符。 输出描述： 输出一行一个数字表示完成所有料理需要多少种不同的材料...
数星星~
Jacketinsysu的专栏
08-02 1344
好吧，昨晚刚刚打完cf，做了两道水题，其实disa
贪心算法
forget_fish的博客
02-10 302
一、分发饼干（LeetCode 455） 题目： 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj &amp;gt;= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个...
牛客网算法——名企高频面试题143题（1）
庄小焱
12-07 699
题目描述 字符串旋转: 给定两字符串A和B，如果能将A从中间某个位置分割为左右两部分字符串（都不为空串），并将左边的字符串移动到右边字符串后面组成新的字符串可以变为字符串B时返回true。 例如：如果A=‘youzan’，B=‘zanyou’，A按‘you’‘zan’切割换位后得到‘zanyou’和B相同返回true。 package 牛客面试必会100题; import org.junit.Test; /** * @Classname 旋转字符串 * @Description TODO
一步一步写算法（之“数星星”）
嵌入式-老费，一个分享专业嵌入式知识的blog
10-29 8723
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】       学过编程的朋友都知道，当初为了学习编程语言中的各种语法结构，我们要试着解决各种各样奇怪的题目。其中“数星星”就似乎其中的一种。什么是“数星星”呢？就是打印各种形状的“*”，正三角、倒三角、菱形等等。本篇博客纯粹为了纪念我们逝去的岁月。     a）正三角 void st
2018阿里暑期实习线上编程题——数星星
Laox1ao的博客
03-22 1472
题目： 对于坐标图中NxN的矩阵图中，每个节点都站着一个人，从（0，0）点往人群中看，有些人能被看到，有些人会被同一直线上的其他人挡住。问对于给定的N，能看到多少人？ 其实相当于计算从原点到整个矩阵的点中一共有多少种斜率，但是无法使用集合等容器，所以遍历斜率的复杂度太高。之后和同学讨论，发现一种挺巧妙的方法：对于那些被前面的人挡住的点来说，他的坐标是可以通过约分来得到该点到原点的直线上...
高频电子线路第3章习题及答案解析
"高频电子线路第3章参考答案.ppt-教程与笔记习题" 这篇资料主要涉及的是高频电子线路课程的第三章习题参考答案，包括了从3-1到3-25共25个习题的解答。高频电子线路是电子工程领域中的重要课程，主要研究的是在高频...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值