题目大意：给你一些函数的起始/终止时间的日志，让你输出每个函数的总运行时间。假设单核单线程，支持递归函数。

对于运算

向下取整：

a/b

向上取整：

(a+b-1)/b

四舍五入：

题目大意：有n个花盆，第i天，第flowers[i]个花盆的花会开。问是否存在一天，两朵花之间有k个空花盆。

　　体育老师小明要将自己班上的学生按顺序排队。他首先让学生按学号从小到大的顺序排成一排，学号小的排在前面，然后进行多次调整。一次调整小明可能让一位同学出队，向前或者向后移动一段距离后再插入队列。

学习

• 发现算法没有想象中那么难 感觉某些时候还是挺有趣的 尤其是当你自己写的代码能AC的时候 注重手写思路
  Read more »

问题描述
　　请实现一个铁路购票系统的简单座位分配算法，来处理一节车厢的座位分配。
<!–more->
假设一节车厢有20排、每一排5个座位。为方便起见，我们用1到100来给所有的座位编号，第一排是1到5号，第二排是6到10号，依次类推，第20排是96到100号。

购票时，一个人可能购一张或多张票，最多不超过5张。如果这几张票可以安排在同一排编号相邻的座位，则应该安排在编号最小的相邻座位。否则应该安排在编号最小的几个空座位中（不考虑是否相邻）。

假设初始时车票全部未被购买，现在给了一些购票指令，请你处理这些指令。

输入格式

输入的第一行包含一个整数n，表示购票指令的数量。

第二行包含n个整数，每个整数p在1到5之间，表示要购入的票数，相邻的两个数之间使用一个空格分隔。

输出格式

输出n行，每行对应一条指令的处理结果。

对于购票指令p，输出p张车票的编号，按从小到大排序。

样例输入

4

2 5 4 2

样例输出

1 2

6 7 8 9 10

11 12 13 14

3 4

样例说明
　　1) 购2张票，得到座位1、2。
　　2) 购5张票，得到座位6至10。
　　3) 购4张票，得到座位11至14。
　　4) 购2张票，得到座位3、4。
评测用例规模与约定
　　对于所有评测用例，1 ≤ n ≤ 100，所有购票数量之和不超过100。

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

#include <iostream>
#include<string.h>
#include<vector>
using namespace std;
int	a[20][5];
int	vis[20][5];
vector<vector<int> >ans;
int main()
{
	int n;
	cin >> n;
	int nn=1;
	for(int i=0;i<20;i++){
		for(int j=0;j<5;j++){
			a[i][j]=nn++;
		} 
		
	}

	int num;
	memset( vis, 0, sizeof(vis) );
	while ( n-- )
	{
		
		cin >> num;
		int flag = 0;
		for ( int j = 0; j < 20; j++ )
		{
			int start=0;
			int cnt = 0, maxi = 0;
			for ( int k = 0; k < 5; k++ )
			{
				
				if ( vis[j][k] == 0 )
					cnt++;
				
			    if(vis[j][k]==1){
					start++;
				
					if ( cnt > maxi )
					{
						start = k - cnt;
					}
					/*	maxi=max(cnt,maxi); */
					cnt = 0;
				}
				
			}
			
			if ( cnt >= num )
			{
			
				flag = 1;
				vector<int> v;
				for ( int p = start; p < start + num; p++ )
				{
					vis[j][p] = 1;
					v.push_back( a[j][p] );
				}
				
				ans.push_back( v );
				break;
			}
		}
		if ( flag == 0 )
		{
			while ( num )
			{
				vector<int> vec;
				for ( int i = 0; i < 20; i++ )
				{
					for ( int t = 0; t < 5; t++ )
					{
						if ( vis[i][t]==0 )
						{

							vec.push_back( a[i][t] );
							num--;
								vis[i][t]=1;
						}
					}
				
				}
				ans.push_back(vec);
			}
		}
		

	}
	for(int i=0;i<ans.size();i++){
		for(int j=0;j<ans[i].size();j++){
			cout<<ans[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
	
}

Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list “parts”.

The length of each part should be as equal as possible: no two parts should have a size differing by more than 1. This may lead to some parts being null.

The parts should be in order of occurrence in the input list, and parts occurring earlier should always have a size greater than or equal parts occurring later.

Return a List of ListNode’s representing the linked list parts that are formed.

The Hamming distance between two integers is the number of positions at which the corresponding bits are different.

Given two integers x and y, calculate the Hamming distance.

We are given an array asteroids of integers representing asteroids in a row.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.

Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.

Example 1:

Input:
asteroids = [5, 10, -5]

Output: [5, 10]

A virus is spreading rapidly, and your task is to quarantine the infected area by installing walls.

The world is modeled as a 2-D array of cells, where 0 represents uninfected cells, and 1 represents cells contaminated with the virus. A wall (and only one wall) can be installed between any two 4-directionally adjacent cells, on the shared boundary.