1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;
int main()
{
  // 请在此输入您的代码
  int result=0;
  for(int i=1;i<=2020;i++){
      int num=i;
      while(num){
         if(num%10==2)
         {
            result+=1;
            break;
         }
         num/=10;
      }
  }
  cout<<result<<endl;
  return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include<iostream>
#include<queue>
using namespace std;
struct node{
	node(int _x,int _y,int _cnt)
	:x(_x)
	,y(_y)
	,cnt(_cnt)
	{
	}
    int x , y , cnt;
    //cnt记录本次移动是第几次移动
};
//因为有的编程语言中数组坐标不支持负数，所以我们整体加上2020

int nex[4][2] = {{1 , 0} , {-1 , 0} , {0 , 1} , {0 , -1}};
const int row=2020+2020+2020+1;
const int col=2000+2020+2020+1;
const int B = 2020;
int map[row][col];
int bfs()
{
    queue<node> que;
    int cnt = 4; // 初始的黑色的点的个数 
    //我们需要使用队列来记录我们需要从那个点进行方向移动
    que.push(node(0 + B , 0 + B , 0));
    que.push(node(2020 + B , 11 + B , 0));
    que.push(node(2000 + B , 2000 + B , 0));
    que.push(node(11 + B , 14 + B , 0));
    map[0 + B][0 + B] = 1;
    map[2020 + B][11 + B] = 1;
    map[2000 + B][2000 + B] = 1;
    map[11 + B][14 + B] = 1;
    while(!que.empty())    
    {
        node u = que.front();
        que.pop();
        //移动次数为2020时，表示我们已经移动了2020分钟，则可以停止扩散了
        if(u.cnt == 2020) continue ;
        for(int i = 0 ; i < 4 ; i ++)
        {
            int tx = u.x + nex[i][0] , ty = u.y + nex[i][1];
            if(map[tx][ty]) continue ;
             cnt ++ ;
            map[tx][ty] = 1;
            que.push(node(tx , ty , u.cnt + 1));
        }
    }
    return cnt;
}
int main()
{
    cout << bfs() << 'n';
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int main(){
	int result=0;
	int num=1;
	for(int i=1;i<=5;++i)
	{
		num*=i;
	}
	for(int i=1;i<=num;i++){
		if(num%i==0)
		{
			cout<<i<<endl;
			result++;
		}
	}
	cout<<"result:"<<result<<endl;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>

using namespace std;

int main(){
	long long result=1;
	int arr[101]={0}; //用来存储质数的指数 ,100以内数的约数不会超过100，故去数组大小为101 
    for(int i=1;i<=100;i++){
	    int tmp=i;
		for(int j=2;j*j<=tmp;j++){
			if(tmp%j==0){
			  //如果找到约数，一直相除，就可以得到此约数的指数，这个约数一定是质数
			  //因为质数2,3在前面即使此处j=4或6，一定取余不为0，在前面已经被分解了
			  while(tmp%j==0){
			       tmp/=j;
			       arr[j]++;
			  }
			}
		} 
		if(tmp>1)
		{
		    //设置该if语句的原因 eg:2  2*2>2 ;进不去上面的for循环，我们需要再次判断，以防遗漏
			//cout<<"i"<<i<<"tmp"<<tmp<<endl;
			arr[tmp]++;
		}
	} 
	for(int i=0;i<101;i++){
		if(arr[i]!=0)
		 result*=(arr[i]+1);
	}
	cout<<result<<endl;
	return 0;
}

1
2
3
4
for(int k=0;k<c-'a';k++){
   dp[j][c]+=dp[j-1][k];
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <iostream>
#include<vector>
using namespace std;

int main(){
	//给字符串前面增加一个空格，使得dp数组的含义容易理解 
    string str=" tocyjkdzcieoiodfpbgcncsrjbhmugdnojjddhllnofawllbhfiadgdcdjstemphmnjihecoapdjjrprrqnhgccevdarufmliqijgihhfgdcmxvicfauachlifhafpdccfseflcdgjncadfclvfmadvrnaaahahndsikzssoywakgnfjjaihtniptwoulxbaeqkqhfwl";
    //字符串的大小 
	int size=str.size();
	//cout<<"size"<<size<<endl;
	//前面一个最近相同字母的位置 
    vector<int> last(26,0);
    //动态规划数组 ，表示前i个字符，以‘a’+j字符结尾构成上升序列的个数
    vector<vector<int> > dp(size,vector<int>(26,0));
    
    for(int i=1;i<size;i++){
    	//直接舍弃第i个字符加入上升序列
		for(int j=0;j<26;j++){
			dp[i][j]=dp[i-1][j];
		}
		//将第i个字符加入上升子序列
		//单独的一个元素可以作为一个上升子序列 
		dp[i][str[i]-'a']++; 
		
		//倘若当前字符为c ,我们需要找前面以a或者b结尾的字符，
		//以此构成递增序列
		for(int j=0;j<str[i]-'a';j++){
			dp[i][str[i]-'a']+=dp[i-1][j];
		}
		//因为题目要求构成本质不同的序列，我们需要找到上一次字符，
		//减去上一次字符对应的次数 
		//（ablb） ab由两种情况前两个字符构成ab 
		//第二种跳过第二个第三个字符与第四个字符构成b 
		//由于要求本质不同的上升序列，我们需要减去重复的情况
		dp[i][str[i]-'a']-= dp[last[str[i]-'a']][str[i]-'a'];
		//更新字符的位置
		last[str[i]-'a']=i;
    }
    long long result=0;
    for(int i=0;i<26;i++){
    	result+=dp[size-1][i];
    }
    cout<<result<<endl;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <iostream>
#include<vector>
using namespace std;
//某个位置放有字符0,表示可以放置字符
vector<vector<char> > vv(4,vector<char>(4,'0'));
int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
void dfs(int row,int col,int count,int& result){
//我们将16个字符全部防止完毕之后，构成一种方法
	if(count>=16){
		result++;
		return;
	}
	//选择四个方向中的一个方向移动
	for(int i=0;i<4;i++){
		int x=row+dir[i][0];
		int y=col+dir[i][1];
		//判断移动后的位置是否合理，越界不合理，我们不能移动；
		//要移动的位置如果已经存放过东西，也不合理，不进行移动
		if(x<0||x>=4||y<0||y>=4){
			continue;
		}
		if(vv[x][y]!='0'){
			continue;
		}
		//存放我们要防止的字符
		vv[row][col]=count+'0';
		dfs(x,y,count+1,result);
		//上一次方法完毕，将该位置字符清除
		vv[row][col]='0';
	}
}
int main(){
	int result=0;
	for(int i=0;i<4;i++){
		for(int j=0;j<4;j++){
		//利用双重循环，使得方盒每个位置都可以设置为起点
			dfs(i,j,1,result);
		}
	}
	cout<<result<<endl;
	return 0;
}