BISTU-(1)-4-17-2016

A：贪心，遍历每次维护一个最便宜的价格，假如当前价格不如此前价格，就用此前价格购买当前数量的肉，每次更新最便宜的价格。

 #include <algorithm>
 #include <iostream>
 #include <iomanip>
 #include <cstring>
 #include <climits>
 #include <complex>
 #include <fstream>
 #include <cassert>
 #include <cstdio>
 #include <bitset>
 #include <vector>
 #include <deque>
 #include <queue>
 #include <stack>
 #include <ctime>
 #include <set>
 #include <map>
 #include <cmath>

 using namespace std;

 typedef struct Node {
     int a;
     int p;
     int day;
 }Node;
 const int maxn = ;
 int n;
 Node orz[maxn];

 int main() {
     // freopen("in", "r", stdin);
     while(~scanf("%d", &n)) {
         int minn = 0x7f7f7f;
         int midx;
         int ans = ;
         for(int i = ; i <= n; i++) {
             scanf("%d %d", &orz[i].a, &orz[i].p);
             if(minn > orz[i].p) {
                 minn = orz[i].p;
                 ans += minn * orz[i].a;
             }
             else {
                 ans += minn * orz[i].a;
             }
         }
         cout << ans << endl;
     }
     return ;
 }

A

B：根据一个性质2^k=2*2^(k-1)，每次计数不同幂的个数，假如有偶数个就向下一个数进位并划归为下一个数的个数(k/2个），直到k是奇数的时候，这时候举一次再更新。

 #include <algorithm>
 #include <iostream>
 #include <iomanip>
 #include <cstring>
 #include <climits>
 #include <complex>
 #include <fstream>
 #include <cassert>
 #include <cstdio>
 #include <bitset>
 #include <vector>
 #include <deque>
 #include <queue>
 #include <stack>
 #include <ctime>
 #include <set>
 #include <map>
 #include <cmath>

 using namespace std;

 typedef long long ll;
 const int maxn = ;
 int n;
 ll dp[maxn];

 int main() {
     // freopen("in", "r", stdin);
     int w;
     while(~scanf("%d", &n)) {
         memset(dp, , sizeof(dp));
         for(int i = ; i <= n; i++) {
             scanf("%d", &w);
             dp[w]++;
         }
         ll ans = ;
         for(int i = ; i < maxn; i++) {
             dp[i+] += dp[i] / ;
             ans += dp[i] % ;
         }
         printf("%I64d\n", ans);
     }
     return ;
 }

B

C：利用fibonacci通项公式，先看对数的性质,loga(b^c)=c*loga(b),loga(b*c)=loga(b)+loga(c);假设给出一个数10234432,

那么log10(10234432)=log10(1.0234432*10^7)【用科学记数法表示这个数】=log10(1.0234432)+7;

log10(1.0234432)就是log10(10234432)的小数部分.

log10(1.0234432)=0.010063744(取对数所产生的数一定是个小数)

再取一次幂:10^0.010063744=1.023443198

取前4位，只需要将这个结果乘1000就可以了。

 #include <algorithm>
 #include <iostream>
 #include <iomanip>
 #include <cstring>
 #include <climits>
 #include <complex>
 #include <fstream>
 #include <cassert>
 #include <cstdio>
 #include <bitset>
 #include <vector>
 #include <deque>
 #include <queue>
 #include <stack>
 #include <ctime>
 #include <set>
 #include <map>
 #include <cmath>

 using namespace std;

 typedef long long LL;
 int f[];
 int n;

 void init() {
     f[] = ;
     f[] = ;
     for(int i = ; i < ; i++) {
         f[i] = f[i-] + f[i-];
     }
 }

 void solve() {
     if(n < ) {
         printf("%d\n", f[n]);
     }
     else {
         int answer;
         double ans = -0.5 * log10(5.0) + n * log10((+sqrt())/);
         ans -= floor(ans);
         ans = pow(, ans);
         answer = int(ans * );
         printf("%d\n", answer);
     }
 }

 int main() {
     // freopen("in", "r", stdin);
     init();
     while(~scanf("%d", &n)) {
         solve();
     }
     return ;
 }

C

D：找出a数组里第k小的，再找出b数组里第m大的，假如a数组里k小的数都比b数组里m大的数小，那就满足条件。

 #include <algorithm>
 #include <iostream>
 #include <iomanip>
 #include <cstring>
 #include <climits>
 #include <complex>
 #include <fstream>
 #include <cassert>
 #include <cstdio>
 #include <bitset>
 #include <vector>
 #include <deque>
 #include <queue>
 #include <stack>
 #include <ctime>
 #include <set>
 #include <map>
 #include <cmath>

 using namespace std;

 const int maxn = ;
 int na, nb;
 int k, m;
 int a[maxn], b[maxn];

 int main() {
     // freopen("in", "r", stdin);
     while(~scanf("%d %d", &na, &nb)) {
         scanf("%d %d", &k, &m);
         for(int i = ; i <= na; i++) scanf("%d", &a[i]);
         for(int i = ; i <= nb; i++) scanf("%d", &b[i]);
         sort(a+, a+na+);
         sort(b+, b+nb+);
         if(a[k] < b[nb-m+]) puts("YES");
         else puts("NO");
     }

     return ;
 }

D

E:某人有n个朋友，这n个朋友有钱数m和关系s两个属性。问如何选择朋友，使得这些朋友之间s最大差距小于d并且钱数是最多。

可以用滑动窗口，将m从小到大，s从大到小排列，这时在一个队列里维护队首和队尾，假如队首和队尾的s差距≥d时，就把队尾扔掉队首入队否则就仅队首入队。此时更新一下当前最大值。

 #include <algorithm>
 #include <iostream>
 #include <iomanip>
 #include <cstring>
 #include <climits>
 #include <complex>
 #include <fstream>
 #include <cassert>
 #include <cstdio>
 #include <bitset>
 #include <vector>
 #include <deque>
 #include <queue>
 #include <stack>
 #include <ctime>
 #include <set>
 #include <map>
 #include <cmath>

 using namespace std;

 typedef long long ll;
 typedef struct Node {
     int m;
     int s;
 }Node;
 const int maxn = ;
 int n, d;
 Node f[maxn];

 bool cmp(Node a, Node b) {
     if(a.m == b.m) return a.s > b.s;
     return a.m < b.m;
 }

 int main() {
     // freopen("in", "r", stdin);
     while(~scanf("%d %d", &n, &d)) {
         for(int i = ; i <= n; i++) {
             scanf("%d %d", &f[i].m, &f[i].s);
         }
         sort(f+, f+n+, cmp);
         ll curans = ;
         ll ans = ;
         int front = ;
         int tail = ;
         while() {
             if(front > n || tail > n) break;
             if(f[tail].m - f[front].m >= d)
                 curans -= f[front++].s;
             else curans += f[tail++].s;
             ans = max(ans, curans);
         }
         printf("%I64d\n", ans);
     }
     return ;
 }

E

F:先排序，知道第1个肯定和第n个离得最远，而和第2个离得最近。同理第n个和第1个离得最远，和第n-1个离得最近。固定这两个，接下来在中间找i，最远的话和1和n比，最近的话和i-1和i+1比。

 #include <algorithm>
 #include <iostream>
 #include <iomanip>
 #include <cstring>
 #include <climits>
 #include <complex>
 #include <fstream>
 #include <cassert>
 #include <cstdio>
 #include <bitset>
 #include <vector>
 #include <deque>
 #include <queue>
 #include <stack>
 #include <ctime>
 #include <set>
 #include <map>
 #include <cmath>

 using namespace std;

 const int maxn = ;
 int n;
 int x[maxn];

 int main() {
     // freopen("in", "r", stdin);
     while(~scanf("%d", &n)) {
         for(int i = ; i <= n; i++) {
             scanf("%d", &x[i]);
         }
         sort(x+,x+n+);
         printf("%d %d\n", abs(x[]-x[]), abs(x[]-x[n]));
         for(int i = ; i < n; i++) {
             printf("%d %d\n", abs(x[i]-x[i-]<abs(x[i]-x[i+]))?abs(x[i]-x[i-]):abs(x[i]-x[i+]),
                                (abs(x[i]-x[n])>abs(x[i]-x[]))?abs(x[i]-x[n]):abs(x[i]-x[]));
         }
         printf("%d %d\n", abs(x[n]-x[n-]), abs(x[]-x[n]));
     }
     return ;
 }

F

G:按照从左到右的顺序，找一个子串。使得这个子串看成是上下左右移动步骤的时候可以走回远点。算算每一个子串里上下左右的个数就行了，假如上的次数等于下的次数，左的次数等于右的次数就说明可以回到原点。

 #include <algorithm>
 #include <iostream>
 #include <iomanip>
 #include <cstring>
 #include <climits>
 #include <complex>
 #include <fstream>
 #include <cassert>
 #include <cstdio>
 #include <bitset>
 #include <vector>
 #include <deque>
 #include <queue>
 #include <stack>
 #include <ctime>
 #include <set>
 #include <map>
 #include <cmath>

 using namespace std;

 const int maxn = ;
 int n;
 char str[maxn];

 int main() {
     // freopen("in", "r", stdin);
     while(~scanf("%d", &n)) {
         scanf("%s", str);
         int ans = ;
         int u, d, l, r;
         for(int i = ; str[i]; i++) {
             u = d = l = r = ;
             for(int j = i; str[j]; j++) {
                 if(str[j] == 'U') u++;
                 if(str[j] == 'D') d++;
                 if(str[j] == 'L') l++;
                 if(str[j] == 'R') r++;
                 if(l == r && u == d) {
                     for(int k = i; k <= j; k++) {
                         printf("%c", str[k]);
                     }
                     printf("\n");
                     ans++;
                 }
             }
         }
         printf("%d\n", ans);
     }
     return ;
 }

G