#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;
}