一些题目的答案(自用)

1.PF_数组选3数求和为1

字符变整型：-'0'

整形变字符：+'0'

#include<iostream>
#include<bits/stdc++.h>
using namespace std;

int main()
{
    string str;
    cin>>str;
    int len=str.length();
  //  cout<<len<<endl;  //bebug
  //  cout<<str[2]<<endl;  //bebug
    stack<int> a;
    int fu=0;
    for(int i=0;i<len;i++)
    {
        if(str[i]=='['&&str[i+2]==',')
        {
            a.push(str[i+1]-'0');
          //  cout<<str[i+1]<<endl; //bebug    //发现忘记转换字符为整数，导致出现字符的码数
        }
            
        if(str[i]=='['&&str[i+3]==',')
        {
          // cout<<str[i+2]<<endl;   //bebug
            fu-=str[i+2]-'0' ;
            a.push(fu);
          //   cout<<fu<<endl; //bebug
            fu=0;
        }
        if(str[i]==','&&str[i-2]==',')
            a.push( str[i-1]-'0');
        if(str[i]==','&&str[i-3]==',')
        {
            fu-=str[i-1]-'0';
            a.push(fu);
         //    cout<<fu<<endl;  //bebug
            fu=0;
        }
        if(str[i]==']'&&str[i-3]==',')
        {
            fu-=str[i-1]-'0';
            a.push(fu);
         //    cout<<fu<<endl;   //bebug
            fu=0;
        }
        if(str[i]==']'&&str[i-2]==',')
        {
            a.push(str[i-1]-'0');
        }
    }
    
        
    int n=a.size();
    int b[n];
    for(int i=n-1;i>=0;i--)
    {
        b[i]=a.top();
   //     cout<<b[i]<<endl; //bebug
        a.pop();
    }
    
    int ch;
    for(int i=0;i<n-1;i++)
        for(int j=i+1;j<n;j++)
        {
            if(b[i]>b[j])
            {
                ch=b[i];
                b[i]=b[j];
                b[j]=ch;
            }
        }
 //   for(int i=0;i<n;i++)
  //      cout<<b[i]<<" ";
    
   bool flag=false;
    for(int k=0;k<n;k++)
    {
        for(int i=k+1,j=n-1;i<j;)
        {
            if(b[i]+b[j]+b[k]==1)
            {
                if(k<i)
                    cout<<"[["<<b[k]<<", "<<b[i]<<", "<<b[j]<<"]]";
                else if(k>j)
                    cout<<"[["<<b[i]<<", "<<b[j]<<", "<<b[k]<<"]]";
                else if(k<=j&&k>=i)
                    cout<<"[["<<b[i]<<", "<<b[k]<<", "<<b[k]<<"]]";
                flag=true;
                break;
            }
            else if(b[i]+b[j]+b[k]<1)
                i+=1;
            else 
                j-=j;
            
        }
        if(flag)
         break;
    }
    
    
    return 0;
}

2.PF_围圈报数去3

#include<iostream>
#include<bits/stdc++.h>
using namespace std;
struct st{
    int num;
    int flag;
};
int main()
{
    int n,m=0;
    cin>>n;
    st stu[n];
    for(int i=0;i<n;i++)
    {
        stu[i].num=i;
        stu[i].flag=1;
    }
   int num=1;
    while(1)
    {
        if(m==n-1) break;
        for(int i=0;i<n;i++)
        {
            if(stu[i].flag)
            {
                if(num==3)
                {
                    stu[i].flag=0;
                    m++;
                    num=1;
                    
                }
                else
                    num++;
            }
        }
    }
    for(int i=0;i<n;i++)
    {
        if(stu[i].flag)
        {
            cout<<stu[i].num;
            break;
        }
    }
    
    
    return 0;
}

3.字符串洗成数组

package jijinpingfen;

public class jjpf {

 static String s;
 static int count =0;
 static int min;
 static int max;
 
 public static void main(String[] args){
  min = 1;
  max = 100;
  s="515352";
  df(0);
  System.out.println(count);
  
  
 }
 
 public static void df(int index)
 {
  if(index==s.length()) count++;
  for(int i = index+1; i <= s.length(); i++ )
  {
   int now =Integer.parseInt(s.substring(index, i));
   if(now<min)
    continue;
   else if(now >= min  && now <= max)
    df(i);
   else
    return ;
   
  }
  
  
 }
}

4.最小覆盖子串

原文链接：https://blog.csdn.net/Zolewit/article/details/89472627
思路：
使用一个滑动窗口来表示s子串。
用一个hash表来表示s子串还需要哪些字母才能包含t的全部字母
另外再用一个count来计数，count等于t的长度，那么该子串就是一个符合条件的子串。
再将左指针向右移动。

string minWindow(string s, string t) {
        //如果s比t短，直接返回空字符串
        if(s.size()<t.size())
            return "";
        
        //hashmap存储还需要多少字符才能达到要求
        //注意：hashmap的值是可以为负数的，比如hashmap[c]=-1就表示该子串所包含的c比要求的还多一个
        //还有，hashmap中的元素项都是t字符串的字符，
        //如果不是t字符串中的字符，我们根本就不处理，右边界直接右移
        map<char,int> hashmap;
        for(auto c:t)
            hashmap[c]= hashmap.find(c)!=hashmap.end() ? hashmap[c]+1 : 1;
        
        //用来计数，所包含的符合要求的字符有多少
        int count=0;
        //目前子串的左右边界指针
        int left=0;
        int right=0;
        //最短长度，以及左右边界
        int minleft=0;
        int minright=0;
        int minlen=INT_MAX;
        
        //窗口向右扩展
        for(;right<s.size();++right){
            //如果s[right]是t中的字符
            if(hashmap.find(s[right]) != hashmap.end()){
                //如果我们还需要s[right]，那么将其纳入窗口后，所包含的符合要求的字符就又多了一个
                if(hashmap[s[right]]>0)
                    ++count;
                //所需要的字符也减少了一个
                --hashmap[s[right]];
            }
            
            //此时我们得到了所需要的子串
            while(count == t.size()){
                //如果该子串更短，则更新记录
                if(right-left<minlen){
                    minright=right;
                    minleft=left;
                    minlen=right-left;
                }
                
                //如果s[left]是t中的字符
                if(hashmap.find(s[left]) != hashmap.end()){
                    //如果s[left]是我们还需要的或者刚刚够的，那么所包含的符合要求的字符就减少一个
                    //如果此时hashmap[s[left]]<0，就说明子串所包含的字符还有多的，不需要减少
                    if(hashmap[s[left]]>=0)
                        --count;
                    //所需要的字符增加一个
                    ++hashmap[s[left]];
                }
                //左边界右移
                ++left;
            }
        }
        //最后如果存在符合条件的子串，则构建该子串
        return minlen == INT_MAX ? "" : string(s.begin()+minleft,s.begin()+minright+1);
}