各种刷题笔记提高自己的code水平 demo

1:

设有n个正整数，将他们连接成一排，组成一个最大的多位整数。

如:n=3时，3个整数13,312,343,连成的最大整数为34331213。

如:n=4时,4个整数7,13,4,246连接成的最大整数为7424613。

解题思路 冒泡排序的应用，如果两个字符串的字典序 nums[j]+nums[j-1]大于nums[j-1]+nums[j] 此时就要交换nums[j]和nums[j-1]

python实现

while True:
    try:
        n=int(input())
        nums_strings=input().split()
        print(nums_strings)
        #print("".join(sorted(nums_strings,key=lambda x,y:-1 if x+y>y+x else 1)))
        #进行冒泡排序的方式
        for i in range(len(nums_strings)-1):
            for j in range(len(nums_strings)-1,i,-1):
                if(nums_strings[j]+nums_strings[j-1]>nums_strings[j-1]+nums_strings[j]):
                    nums_strings[j],nums_strings[j-1]=nums_strings[j-1],nums_strings[j]
        print("".join(nums_strings))
    except:
        break

C++实现代码：变形的冒泡排序的使用（对于会有溢出的数字，往往采用的是字符串或者是数组去表示）

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
bool compare(string x,string y){
    return x+y>y+x;
}
int main(){
    int n;
    while(cin>>n){
        vector<string>temp(n);
        for(int i=0;i<n;i++){
            cin>>temp[i];
        }
        sort(temp.begin(),temp.end(),compare);
        for(int i=0;i<n;i++){
            cout<<temp[i];
        }
        cout<<endl;
    }
    
    
}

2:将字符串进行反向输出：

python实现

mystring=input()
print(" ".join(mystring.split()[::-1]))

C++实现：通过借助stringstream 字符串流来实现；

#include<iostream>
#include<vector>
#include<string>
#include<sstream>
using namespace std;
void reverse(vector<string> &temp,string ss){
    stringstream scin;
    scin<<ss;
    string temps;
    while(scin>>temps){
        temp.push_back(temps);
    }
}
int main(){
    string mystring;
    getline(cin,mystring);
    vector<string> temp;
    reverse(temp,mystring);
    for(int i=temp.size()-1;i>0;i--){
        cout<<temp[i]<<' ';
    }
    cout<<temp[0]<<endl;
    
}

3:

首先将电话号码中的每个数字加上8取个位，然后使用对应的大写字母代替（"ZERO", "ONE", "TWO", "THREE","FOUR", "FIVE", "SIX", "SEVEN","EIGHT", "NINE"）， 然后随机打乱这些字母，所生成的字符串即为电话号码对应的分身。

思路根据特点统计出相应的字符串的个数，然后组合成变换后的数字，然后转换成变换前的数字（从小到大输出）

python实现

#统计出有多少个数据
def calculate(mystring):
    temp=[0]*10
    temp[0]=mystring.count("Z")
    temp[2]=mystring.count("W")
    temp[4]=mystring.count("U")
    temp[6]=mystring.count("X")
    temp[7]=mystring.count("S")-temp[6]
    temp[5]=mystring.count("V")-temp[7]
    temp[3]=mystring.count("R")-temp[4]-temp[0]
    temp[8]=mystring.count("G")
    temp[1]=mystring.count("O")-temp[0]-temp[2]-temp[4]
    temp[9]=mystring.count("I")-temp[6]-temp[5]-temp[8]
    return temp

n=int(input())
for i in range(n):
    mystring=input()
    res=""
    temp=calculate(mystring)
    for i, r in enumerate(temp):
        res+=r*str(i)
    ans=""
    for i in res:
        if(int(i)>=8):
            ans+=str(int(i)-8)
        else:
            ans+=str(int(i)+10-8)
    print("".join(sorted(ans)))

4:

水鲜花树python实现 判断一定范围内的水鲜化数

while True:
    try:
        begin,end=map(int,input().split())
        ans=[]
        for i in range(begin,end+1):
            temp=str(i)
            result=0
            for j in temp:
                result+=int(j)**3
            if(result==i):
                ans.append(i)
        if(len(ans)==0):
            print("no")
        else:
            print(" ".join(map(str,ans)))
    except:
        break

C++实现就不写了 思路比较简单的还是；

5:袋鼠过河问题：

一只袋鼠要从河这边跳到河对岸，河很宽，但是河中间打了很多桩子，每隔一米就有一个，每个桩子上都有一个弹簧，袋鼠跳到弹簧上就可以跳的更远。每个弹簧力量不同，用一个数字代表它的力量，如果弹簧力量为5，就代表袋鼠下一跳最多能够跳5米，如果为0，就会陷进去无法继续跳跃。河流一共N米宽，袋鼠初始位置就在第一个弹簧上面，要跳到最后一个弹簧之后就算过河了，给定每个弹簧的力量，求袋鼠最少需要多少跳能够到达对岸。如果无法到达输出-1

输入：

5
2 0 1 1 1

输出：

4

解题思路：动态规划问题，用dp[i]表示跳到i位置所需要的最小的跳数；dp[0]=0 dp[i+1]=min(dp[i+1],dp[i]+1)

python实现：

#动态规划的问题：
#python设置无穷大

num=int(input())
nums=[int(x)for x in input().split()]
#动态规划数组的定义
inf=float('inf')
dp=[inf]*(num+1)
dp[0]=0
for i in range(num):
    j=1
    while j<=nums[i] and i+j<=num:
        dp[i+j]=min(dp[i+j],dp[i]+1)
        j+=1
if(dp[num]!=inf):
    print(dp[num])
else:
    print(-1)

C++实现：

#include<iostream>
#include<vector>
#include<string>
#include<sstream>
#include<algorithm>
using namespace std;
int main(){
    int n;
    cin>>n;
    vector<int> nums;
    for(int i=0;i<n;i++){
        int temp;
        cin>>temp;
        nums.push_back(temp);
    }
    vector<int> ans(n+1,10240);
    ans[0]=0;
    for(int i=0;i<n;i++){
        int j=1;
        while(j<=nums[i]&&(i+j)<=n){
            ans[i+j]=min(ans[i+j],ans[i]+1);
            j++;
        }
    }
    if(ans[n]!=10240){
        cout<<ans[n]<<endl;
    }
    else{
        cout<<-1<<endl;
    }
}

6：全排列的问题：给定一个数组求该数组的全排列问题：

其实这个问题不是全排列，是可以重复抽样的排列

下面才是全排列的实现方式：

void show(vector<vector<int>>& ans) {
	for (int i = 0; i < ans.size(); i++) {
		for (int j = 0; j < ans[i].size(); j++) {
			
			cout << ans[i][j];
		}
		
		cout << endl;
		cout << "hello" << endl;
	}
}
void printNQsort(vector<vector<int>> &all,vector<int> &ans, vector<int> & nums, int N, int index) {
	if (index == nums.size()-1) {
		all.push_back(ans);
		return;
	}
	for (int i = 0; i < nums.size(); i++) {
		ans[index + 1] = nums[i];
		printNQsort(all,ans, nums, N, index + 1);
	}
}
void find_path(vector<vector<int>>& ans, vector<int>& path, vector<int>nums, vector<bool>& flag, int index, int N) {
	if (path.size() == N) {
		ans.push_back(path);
		return;
	}
	for (int i = 0; i < N; i++) {
		if (flag[i] == false) {
			path.push_back(nums[i]);
			flag[i] = true;
			find_path(ans, path, nums, flag, index + 1, N);
			path.pop_back();
			flag[i] = false;
		}
	}
}
int main() {
	int N;
	cin >> N;
	vector<int>nums(N, 0);
	int temp;
	for (int i = 0; i < N; i++) {
		cin >> temp;
		nums[i] = temp;
	}
	vector<int> ans;
	vector<vector<int>> all;
	//下面是真正的全排列的代码
	vector<bool> flag(N, false);
	find_path(all, ans, nums,flag, 0, N);

	show(all);
	system("pause");
}

递归的方式来实现

C++实现：

#include<iostream>
#include<vector>
#include<string>
#include<cmath>
using namespace std;
//实现的功能是打印出数组的全排列 递归实现
void printNQsort(vector<int> &ans, vector<int> & nums, int N, int index) {
	if (index==N - 1) {
		for (int i = 0; i < N; i++) {
			cout << ans[i];
		}
		cout << endl;
		return;
	}
	for (int i = 0; i < N; i++) {
		ans[index + 1] = nums[i];
		printNQsort(ans, nums,N, index + 1);
	}

}

int main() {
	int N;
	cin >> N;
	vector<int>nums(N, 0);
	int temp;
	for (int i = 0; i < N; i++) {
		cin >> temp;
		nums[i] = temp;
	}
	vector<int> ans(N, 0);
	for (int i = 0; i < N; i++) {
		
		ans[0] = nums[i];
		printNQsort(ans,nums, N, 0);

	}
	system("pause");
}

python实现

#全排列的实现
def quanpailie(ans,nums,N,index):
    if(index==N-1):
        print("".join(map(str,ans)))
        return
    else:
        for item in nums:
            ans[index+1]=item
            quanpailie(ans,nums,N,index+1)

N=int(input())
mylist=[int(item) for item in input().split()]

ans=[0]*N
for num in mylist:
    ans[0]=num
    quanpailie(ans,mylist,N,0)

全排列的应用：

打印从1到最大的N位数：由于N的数值可能很大，所以直接输出肯定会有溢出的情况发生；

void printNQsort(vector<int> &ans, int N, int index) {
	if (index==N-1) {
		for (int i =0; i<N; i++) {
			cout << ans[i];
		}
		//cout << endl;
		return;
	}
	for (int i = 0; i <=9; i++) {
		ans[index + 1] = i;
		printNQsort(ans,N, index + 1);
	}

}
int main() {
	int N;
	cin >> N;
	vector<int> ans(N, 0);
	for (int i = 0; i < 10; i++) {		
		ans[0] =i;
		printNQsort(ans, N, 0);
	}
	system("pause");
}

python实现：

#全排列法实现输出0-N的N位整数；
def quanpailie(ans,N,index):
    if(index==N-1):
        num_string="".join(map(str,ans))
        #print(type(num_string))
        i=0
        while(num_string[i]=='0' and i<len(num_string)-1):
            i+=1
        print(num_string[i:])
        return
    else:
        for item in range(10):
            ans[index+1]=item
            quanpailie(ans,N,index+1)
N=int(input())
ans=[0]*N
for num in range(10):
    ans[0]=num
    quanpailie(ans,N,0)

 

7：删除单个链表，时间复杂度为O(1)的情况下：

单纯的删除链表的时间复杂度为O(n) 不保留相应的重复结点

C++实现

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if(pHead==NULL){
            return pHead;
        }
        ListNode* pre=NULL;
        ListNode* curr=pHead;
        //ListNOde* Next=pHead->next;
        while(curr!=NULL){
            ListNode *Next=curr->next;
            bool needDel=false;//表示当前节点是否应该删除
            if(Next!=NULL&&curr->val==Next->val){
                needDel=true;
            }
            if(!needDel){
                pre=curr;
                curr=Next;//将节点后移
            }
            else{
                int tempval=curr->val;
                ListNode *toDelNode=curr;
                while(toDelNode!=NULL&&toDelNode->val==tempval){
                    Next=toDelNode->next;//指向下一个结点；
                    delete toDelNode;
                    toDelNode=NULL;
                    toDelNode=Next;
                }
                if(pre==NULL){
                    pHead=Next;//pHead=toDelNode;
                }
                else{
                    pre->next=Next;
                }
                curr=Next;
            }
        }
        return pHead;
    }
};

python实现：

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteDuplication(self, pHead):
        # write code here
        if(pHead==None):
            return pHead
        preNode=ListNode(-1)
        preNode.next=pHead
        anNode=preNode
        currNode=pHead
        while(currNode!=None):
            Next=currNode.next
            needDel=False
            if(Next!=None and Next.val==currNode.val):
                needDel=True
            if(needDel==False):
                preNode=currNode
                currNode=Next
            else:
                temp=currNode.val#保存住当前的值；
                needDel=currNode
                while(needDel!=None and needDel.val==temp):
                    Next=needDel.next
                    del needDel
                    needDel=Next
                preNode.next=Next
                currNode=Next
        return anNode.next

8.表示数值的字符串： 指针的终极使用；

C++实现

class Solution {
public:
    bool isNumeric(char* string)
    {
        //使用C字符串的形式 来表示 指针的终极应用
        if(string==NULL){
            return false;
        }
        if(*string=='+'||*string=='-'){
            ++string;//指向下一个地址值
        }
        scanNum(&string);
        if(*string=='\0'){
            return true;//表示只有数据
        }
        if(*string=='.'){ //处理小数
            string++;
            if(*string=='\0'){//小数点后面没有数 
                return false;
            }
            scanNum(&string);
            if(*string=='\0'){//小数点后面只有数字
                return true;
            }
            else if(*string=='e'||*string=='E'){
                string++;
                return scanExp(&string);
            }
        }
        if(*string=='e'||*string=='E'){
            string++;
            return scanExp(&string);
        }
        return false;
    }
    void scanNum(char** string){
        while(**string!='\0'&&**string>='0'&&**string<='9'){
            ++(*string);
        }
    }
    bool scanExp(char** string){
        if(**string=='\0'){
            return false;
        }
        if(**string=='+'||**string=='-'){
            ++(*string);
            if(**string=='\0'){
                return false;
            }
        }
        scanNum(string);
        if(**string=='\0')
            return true;
        else
            return false;
        return false;
    }
};

python实现直接使用正则表达式就可以了：

9：调整数组元素的顺序，使得数组中的元素奇数位于偶数的前面

C++实现：

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        //采用双指针的方式来进行改变相应的数组中的元素
        int left=0;
        int right=array.size()-1;
        while(left<right){
            if(array[left]%2==0&&array[right]%2==1){
                swap(array[left],array[right]);
                left++;
                right--;
            }
            else if(array[left]%2==1){
                left++;
            }
            else{
                right--;
            }
        }
        //不考虑顺序关系时使用这种方法 两个指针交换的方式；
    }
};

python实现：

def reOrderArray(self, array):#使用空间复杂度为O(n)的算法
        # write code here
        nums1=[]
        nums2=[]
        for item in array:
            if(item%2==0):
                nums2.append(item)
            else:
                nums1.append(item)
        nums1.extend(nums2)
        return nums1

10:求解链表中的倒数第k个结点

C++实现，注意边界条件的问题

ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
           ListNode *first=pListHead;
           ListNode *second=pListHead;
           int i=0;
           while(second!=NULL&&i<k){
               second=second->next;
               i++;
           }
           if(second==NULL&&i<k){
               return NULL;
           }
           if(second==NULL){
               return first;
           }
           while(second!=NULL){
               second=second->next;
               first=first->next;
           }
           return first;
    }

python实现：可以直接上面的思路两个指针的方式

11:反转链表：

C++实现：

ListNode* ReverseList(ListNode* pHead) {
        //通过三个指针来反转链表
        ListNode *pre=NULL;
        ListNode *curr=pHead;
        if(curr==NULL){
            return pHead;
        }
        ListNode *Next=curr->next;
        while(Next!=NULL){
            ListNode *temp=Next->next;
            curr->next=pre;
            Next->next=curr;
            pre=curr;
            curr=Next;
            Next=temp;
        }
        return curr;
    }

12：合并两个排序的链表：

C++实现：

ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        //开辟一个新的空间，空间复杂度为O(n)
        //使用递归的写法：
        if(pHead1==NULL){
            return pHead2;
        }
        if(pHead2==NULL){
            return pHead1;
        }
        ListNode *ans=NULL;
        if(pHead1->val<pHead2->val){
             ans=pHead1;
             ans->next=Merge(pHead1->next,pHead2);
        }
        else{
            ans=pHead2;
            ans->next=Merge(pHead2->next,pHead1);
        }
        return ans;
    }

python 实现：

def Merge(self, pHead1, pHead2):
        # write code here
        if(pHead1==None):
            return pHead2
        if(pHead2==None):
            return pHead1
        node=ListNode(-1)
        if(pHead1.val<pHead2.val):
            node=pHead1
            node.next=self.Merge(pHead1.next,pHead2)
        else:
            node=pHead2
            node.next=self.Merge(pHead2.next,pHead1)
        return node

13:求一棵树的镜像：

C++实现

void Mirror(TreeNode *pRoot) {
        //之前做过的题是交换二叉树的左右子树
        /*
        if(pRoot==NULL){
            return ;
        }
        if(pRoot->left==NULL&&pRoot->right==NULL){
            return;
        }
        else{
            swap(pRoot->left,pRoot->right);
        }*/
        //还是使用递归的方式来实现
        if(pRoot==NULL){
            return;
        }
        if(pRoot->left==NULL&&pRoot->right==NULL){
            return;
        }
        swap(pRoot->left,pRoot->right);
        if(pRoot->left){
            Mirror(pRoot->left);
        }
        if(pRoot->right){
            Mirror(pRoot->right);
        }
    }

python实现：

class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if(root==None):
            return
        if(root.left==None and root.right==None):
            return
        root.left,root.right=root.right,root.left
        if(root.left!=None):
            self.Mirror(root.left)
        if(root.right!=None):
            self.Mirror(root.right)

14:判断一棵树是否是对称树：

C++实现

class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        //创建两个树进行比较
        return isbool(pRoot,pRoot);
    }
    bool isbool(TreeNode *root1,TreeNode* root2){
        if(root1==NULL&&root2==NULL){
            return true;
        }
        if(root1==NULL||root2==NULL){
            return false;
        }
        if(root1->val!=root2->val){
            return false;
        }
        return isbool(root1->left,root2->right)&&isbool(root1->right,root2->left);
    }

};

15:包含一个可以去到最小值的栈，要求时间复杂度为O(1)

解题思路就是用空间来换取时间，通过构建一个新的数据栈

数据栈中的栈顶始终是栈中的最小值；

C++实现：

class Solution {
public:
    void push(int value) {
        ss.push(value);
        if(temp.size()==0||value<temp.top()){
            temp.push(value);
        }
        else{
           temp.push(temp.top()); 
        }
       }
    void pop() {
        ss.pop();
        temp.pop();
    }
    int top() {
        return ss.top();
    }
    int min() {
        return temp.top();
    }
    stack<int> ss;
    stack<int> temp;//使用一个辅助栈来保存相应的数据
};

16:二叉树中某一路径和为某一值的路径，

递归和回溯解法(不应该不熟悉啊)

C++实现（之前是数组，现在是树而已）

vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
            //递归和回溯的方法来进行解题
        vector<vector<int>> ans;
        if(root==NULL){
            return ans;
        }
        vector<int> path;
        int current=0;
        dfs(ans,path,root,expectNumber,current);
        return ans;
    }
    void dfs(vector<vector<int>> &ans, vector<int>& temp,TreeNode* root,int expectNumber,int current){
        current+=root->val;
        temp.push_back(root->val);
        if(current==expectNumber&&root->left==NULL&&root->right==NULL){
            ans.push_back(temp);
            return;
        }
        if(root->left!=NULL){
            dfs(ans,temp,root->left,expectNumber,current);
            temp.pop_back();
        }
        if(root->right!=NULL){
            dfs(ans,temp,root->right,expectNumber,current);
            temp.pop_back();
        }
    }

17:字符串的全排列，含有重复字符的情况下，一开始想到的是使用递归和回溯算法来实现相应的排序，但是对于重复字符串存在问题

所以使用剑指offer中的方式来实现

C++实现

vector<string> Permutation(string str) {
        vector<string> ans;
        if(str.size()==0){
            return ans;
        }
        detail_permutation(ans,str,0,str.size());
        map<string,int> mymap;
        for(int i=0;i<ans.size();i++){
            mymap[ans[i]]+=1;
        }
        vector<string> result;
        map<string,int>::iterator it=mymap.begin();
        for(it;it!=mymap.end();it++){
            result.push_back(it->first);
        }
        return result;
    }
   void  detail_permutation(vector<string> &ans,string &str,int index,int N){
       if(index==N){
           ans.push_back(str);
           return;
       }
       for(int i=index;i<N;i++){
           swap(str[index],str[i]);
           detail_permutation(ans,str,index+1,N);
           swap(str[index],str[i]);
       }
   }

python实现： 需要注意的是python中的字符串是不可变的类型不能进行赋值操作；所以要先转换为字符列表；

class Solution:
    def Permutation(self, ss):
        # write code here
        ans=[]
        if(len(ss)==0):
            return ans
        ss_list=[]
        for char in ss:
            ss_list.append(char)
        self.mypermulate(ans,ss_list,0,len(ss))
        return ans
    def mypermulate(self,ans,ss,index,N):
        if(index==N):
            ans.append(''.join(ss))
            return
        else:
            for i in range(index,N):
                ss[i],ss[index]=ss[index],ss[i]
                self.mypermulate(ans,ss,index+1,N)
                ss[i],ss[index]=ss[index],ss[i]

18：把数字翻译成字符串的方式：

使用两种方式：一种是递归的方式，另外一种是动态规划方式;

C++动态规化

int main() {
	string ss;
	cin >> ss;
	int size = ss.size();
	if (size == 0) {
		cout << 0 << endl;
	}
	vector<int> ans(size + 1, 0);
	ans[size] = 1;
	ans[size - 1] = 1;
	for (int i = size - 2; i >= 0; i--) {
		//动态规划寻找相应的数值
		if (ss[i] - '0' >= 1 && ss[i] - '0' <= 2&& ss[i + 1] - '0' <= 5&&ss[i+1]-'0'>=0) {
			ans[i] = ans[i + 1] + ans[i + 2];
		}
		else if (ss[i] - '0' == 1 && ss[i + 1] - '0' <= 9 && ss[i + 1] - '0' >= 0) {
			ans[i] = ans[i + 1] + ans[i + 2];
		}
		else {
			ans[i] = ans[i + 1];
		}

	}
	cout << ans[0] << endl;
	system("pause");

}

19：礼物的最大价值的实现：

还是使用动态规划的思想来实现：

int main() {
	int m, n;
	cin >> m >> n;
	vector<vector<int>> nums(m, vector<int>(n, 0));
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			cin >> nums[i][j];
		}
	}
	//使用二维数组来保存相应的结果;
	vector<vector<int>> temp(m, vector<int>(n, 0));
	temp[m - 1][n - 1] = nums[m - 1][n - 1];
	for (int i = m - 2; i >= 0; i--) {
		temp[i][n - 1] = temp[i+1][n - 1] + nums[i][n - 1];
	}
	for (int i = n - 2; i >= 0; i--) {
		temp[m - 1][i] = temp[m - 1][i + 1] + nums[m - 1][i];
	}
	for (int i = m - 2; i >= 0;i--) {
		for (int j = n - 2; j >= 0; j--) {
			temp[i][j] = nums[i][j] + max(temp[i + 1][j], temp[i][j + 1]);
		}
	}
	cout << temp[0][0];
	system("pause");

}

20：

最长不含重复字符的子字符串（最长无重复字符串）;

int max(vector<int > ans) {
	int Max = 0;
	for (int i = 0; i < ans.size(); i++) {
		Max = max(ans[i], Max);
	}
	return Max;
}
int main() {
	string ss;
	cin >> ss;
	int size = ss.size();
	vector<int> ans(size, 0);
	vector<int> flag(256, -1);
	//设定一个标志 用来表示字符串是否出现过 等信息
	ans[0] = 1;
	flag[ss[0] - 'a'] = 0;//0表示出现的索引
	for (int i = 1; i < size; i++) {
		if (flag[ss[i] - 'a'] == -1) {
			ans[i] = ans[i - 1] + 1;
			flag[ss[i] - 'a'] = i;
		}
		else {
			int d = i - flag[ss[i] - 'a'];
			if (d <=ans[i - 1]) {
				ans[i] = d;
				//将数据更新为i
				flag[ss[i] - 'a'] = i;
			}
			else {
				ans[i] = ans[i - 1]+1;
				flag[ss[i] - 'a'] = i;
			}
		
		}
	}
	cout << max(ans);
	system("pause");

}

python 实现：

while True:
    try:
        mystring=input()
        result=[-1]*256
        ans=[0]*len(mystring)
        ans[0]=1
        for i in range(2,len(mystring)):
            if(result[ord(mystring[i])-ord('a')]==-1):
                ans[i]=ans[i-1]+1
                result[ord(mystring[i])-ord('a')]=i
            else:
                d=i-result[ord(mystring[i])-ord('a')]
                if(d>ans[i-1]):
                    ans[i]=ans[i-1]+1
                    result[ord(mystring[i])-ord('a')] = i
                else:
                    ans[i]=d
                    result[ord(mystring[i])-ord('a')] = i
        print(max(ans))
    except:
        break