Solution

A:Careful Thief

题意:给出n个区间,每个区间的每个位置的权值都是v,然后找长度为k的区间,使得这个区间的所有位置的权值加起来最大,输出最大权值, 所有区间不重叠

思路:贪心的想法,长度为k的区间的起始点肯定是某个区间的起始点,或者长度为k的区间的结束点肯定是某个区间的结束点。

因为存在最优的答案,它的起点不在某个区间的起点,那么只有两种情况。

1° 不属于任何已知区间

2° 在某个已知区间的内部

首先考虑第一种情况  如果不属于任何已知区间,那么根据贪心,我肯定能够往右移使得它是某个区间起点,这样得到的新的答案肯定大于等于原来的答案,因为我移动的这段区间的权值都为0

那么第二种情况,假如现在涵盖的区间横跨两个区间,那么我肯定能够右移结束点使得它与最后的那个区间的结束点对齐,或者左移起始点使得它跟最左边涵盖到的区间的起始点对齐,使得答案更大

然后双指针搞一搞

 #include <bits/stdc++.h>

 using namespace std;

 #define ll long long

 #define N 100010

 int t, m, k;

 struct node
{
int l, r;
ll v;
ll sum;
inline node() {}
inline node(int l, int r, int v) : l(l), r(r), v(v) {} inline void scan()
{
scanf("%d%d%lld", &l, &r, &v);
sum = (ll)(r - l + ) * v;
} inline bool operator < (const node& b) const
{
return l < b.l;
}
}arr[N]; int main()
{
scanf("%d", &t);
while (t--)
{
scanf("%d%d", &m, &k);
for (int i = ; i <= m; ++i)
arr[i].scan(); sort(arr + , arr + m + );
int L, R;
int j = ;
ll ans = ;
ll tmp = ;
for (int i = ; i <= m; ++i)
{
L = arr[i].l;
R = L + k - ;
while (arr[j].r <= R && j <= m)
{
tmp += arr[j].sum;
++j;
}
ll res = ;
if(j <= m)
{
res = arr[j].v * max(, R - arr[j].l + );
}
tmp += res;
ans = max(ans, tmp);
tmp -= res;
tmp -= arr[i].sum;
}
tmp = ;
j = m;
for(int i = m; i >= ; --i)
{
R = arr[i].r;
L = R - k + ;
while(arr[j].l >= L && j >= )
{
tmp += arr[j].sum;
--j;
}
ll res = ;
if(j >= )
{
res = arr[j].v * max(, arr[j].r - L + );
}
tmp += res;
ans = max(ans, tmp);
tmp -= res;
tmp -= arr[i].sum;
}
printf("%lld\n",ans);
}
return ;
}

B:Friends and Cookies

水。

 #include <bits/stdc++.h>

 using namespace std;

 #define ll long long

 #define N 1010

 int t, n;

 ll x;

 ll ans[N];

 int main()
{
scanf("%d", &t);
while (t--)
{
scanf("%lld%d", &x, &n);
if (n == )
{
printf("%lld\n", x);
continue;
}
ll len = n + n - ;
ll base = x / len;
ll MOD = x % len;
for (int i = ; i <= n; ++i)
{
if (i != && i != n)
ans[i] = base << ;
else
ans[i] = base;
}
for (int i = ; i <= n && i <= MOD; ++i)
{
ans[i]++;
}
for (int i = n + ; i <= MOD; ++i)
{
ans[ * n - i]++;
}
for (int i = ; i <= n; ++i) printf("%lld%c", ans[i], " \n"[i == n]);
}
return ;
}

C:Flip the Bits

水。

 #include <bits/stdc++.h>

 using namespace std;

 int t, n;

 int main()
{
scanf("%d", &t);
while (t--)
{
scanf("%d", &n);
if (n & )
{
puts("");
continue;
}
else
{
int ans = ;
while ((n & ) == && n)
{
++ans;
n >>= ;
}
printf("%d\n", ans);
}
}
return ;
}

D:Magic Sticks

题意:有n * m 的矩形 每个矩形四条边,从这些边中选取一个边的集合,使得任意两条边不相交,并且每个矩形至少有一条边被选中

思路:

偶数 * 偶数

奇数 * 奇数

奇数 * 偶数

 #include <bits/stdc++.h>

 using namespace std;

 #define ll long long

 #define INFLL 0x3f3f3f3f3f3f3f3f

 int t;
ll n, m; int main()
{
scanf("%d", &t);
while (t--)
{
scanf("%lld%lld", &n, &m); ll ans = INFLL; if (n % == && m % == )
{
ans = min(ans, (n / ) * (m + ));
ans = min(ans, (m / ) * (n + ));
}
else if (n % == && m % == )
{
ans = min(ans, ((n + ) / ) * m);
ans = min(ans, ((m + ) / ) * n);
}
else
{
if (n % == ) swap(n, m);
ans = min(ans, ((n + ) / * m));
ans = min(ans, ((n + ) / ) * (m / ) + (n / ) * (m + ) / );
}
printf("%lld\n", ans);
}
return ;
}

E:N - Dimensional Grid

题意: 在n维的空间,给你每个空间的长度,求有多少个格子相邻

思路:

一维:a1 - 1

二维:(a1 - 1) * a2 + (a2 - 1) * a1

大胆推广到高维:(a1 - 1) * (a2 + ... + an)  + (a2 - 1) * (a1 + a3 + ... + an) ...

然后前缀后缀搞一搞

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long ll;

 const int MOD = 1e9 + ;
#define N 100010 int t,n;
ll arr[N],brr[N],crr[N]; int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
for(int i = ; i <= n; ++i)
{
scanf("%lld",&arr[i]);
}
brr[] = ;
for(int i = ; i <= n; ++i)
{
brr[i] = (brr[i - ] * arr[i]) % MOD;
}
crr[n + ] = ;
for(int i = n; i >= ; --i)
{
crr[i] = (crr[i + ] * arr[i]) %MOD;
}
ll ans = ;
for(int i = ; i <= n; ++i)
{
ans = (ans + brr[i - ] * (arr[i] - ) %MOD * crr[i + ] %MOD) %MOD;
}
printf("%lld\n",ans);
}
return ;
}

F:Minimum Sum of Array

题意:给出n个数,如果ai 可以整除aj,那么 ai 可以变成aj,求尽可能变换后,所有数的总和最小

思路:显然,贪心的想法是,对于每个数我们都给它变成这个数列中它跟它不互素的最小数,用类似素数筛法的思想去筛

 #include <bits/stdc++.h>

 using namespace std;

 #define N 100010

 #define M 1000010

 #define ll long long

 int t, n;
int arr[N];
int vis[M];
int used[M]; int main()
{
scanf("%d", &t);
while (t--)
{
scanf("%d", &n);
for (int i = ; i <= n; ++i)
scanf("%d", arr + i);
sort(arr + , arr + + n);
for (int i = ; i <= arr[n]; ++i)
vis[i] = i, used[i] = ;
for (int i = ; i <= n; ++i)
{
int v = arr[i];
if (v >= (arr[n] / + )) break;
if (vis[v] == v && used[v] == )
{
used[v] = ;
for (int j = v * ; j <= arr[n]; j += v)
vis[j] = min(vis[j], v);
}
}
ll ans = ;
for (int i = ; i <= n; ++i) ans += vis[arr[i]];
printf("%lld\n", ans);
}
return ;
}

G:Power of String

题意:给出一个式子,求修改最多k个字符,使得这个式子的值最大

思路:根据这个式子,我们可以知道假如一个字符有n个,那么这n个字符的值是(n * (n - 1)) / 2 * ASCII(ch)

那么我们可以把所有字符放在一起看

贪心的想法,如果存在答案,肯定是若干个小于等于k个字符变成同一个字符,因为这样会使得式子更大

那么我们枚举26个字符,使这个字符使要变成的字符

然后我们考虑,尽量让个数小的去换掉,那么个数小于等于k的字符就可以去做01背包,然后再枚举26位来当做补充

 #include <bits/stdc++.h> 

 using namespace std;

 #define READ freopen("Test.in", "r", stdin);
#define N 100010
#define M 5010
#define ll long long
#define INFLL 0x3f3f3f3f3f3f3f3f int t, n, K;
char s[N]; ll num[]; inline ll F(ll x)
{
return (x * (x - )) / ;
} inline ll Get(char c, ll pre, ll now)
{
ll res = ;
res = F(now) * c;
res -= F(pre) * c;
return res;
} ll dp[M];
ll f[M]; inline ll work(char c)
{
for (int i = ; i <= K; ++i) f[i] = -INFLL;
for (int i = 'a'; i <= 'z'; ++i)
{
if (i == c) continue;
if (num[i] == ) continue;
dp[] = ;
for (int j = ; j <= K; ++j) dp[j] = -INFLL;
for (int j = 'a'; j <= 'z'; ++j)
{
if (j == c || j == i) continue;
for (int l = K; l >= num[j]; --l)
dp[l] = max(dp[l], dp[l - num[j]] + Get(j, num[j], ));
}
ll tot = num[i];
for (int j = K; j >= ; --j)
{
if (tot + j <= K)
dp[tot + j] = max(dp[tot + j], dp[j] + Get(i, tot, ));
else
dp[K] = max(dp[K], dp[j] + Get(i, tot, tot - K + j));
}
for (int j = ; j <= K; ++j) f[j] = max(f[j], dp[j]);
}
ll res = ;
for (int i = ; i <= K; ++i)
res = max(res, f[i] + Get(c, num[c], num[c] + i));
return res;
} int main()
{
#ifdef LOCAL
READ;
#endif
scanf("%d", &t);
while (t--)
{
scanf("%d%d", &n, &K);
scanf("%s", s);
memset(num, , sizeof num);
for (int i = ; s[i]; ++i)
num[s[i]]++;
ll ans = , tmp = ;
for (int i = 'a'; i <= 'z'; ++i)
ans += F(num[i]) * i;
tmp = ans;
for (int i = 'a'; i <= 'z'; ++i)
ans = max(ans, tmp + work(i));
printf("%lld\n", ans);
}
return ;
}

H:Making Friends

水。

 #include <bits/stdc++.h>

 using namespace std;

 #define N 2010

 int t, n;

 int arr[N];

 int main()
{
scanf("%d", &t);
while (t--)
{
scanf("%d", &n);
for (int i = ; i <= n * ; ++i)
scanf("%d", arr + i);
int ans = ;
for (int i = ; i <= n; ++i)
ans = max(ans, arr[i] + arr[ * n - i + ]);
printf("%d\n", ans);
}
return ;
}

I: Split the Number

水。

 #include <bits/stdc++.h>

 using namespace std;

 int t, x, n;

 int main()
{
scanf("%d", &t);
while (t--)
{
scanf("%d%d", &x, &n);
if (x < n)
{
puts("-1");
continue;
}
int base = x / n;
int MOD = x % n;
for (int i = ; i <= n; ++i)
{
printf("%d%c", base + ((n - i + <= MOD) ? : ), " \n"[i == n]);
}
}
return ;
}

J:T-Shirts Dilemma

题意:给出 a b v  在a - b 中找出一个连续子区间,使得这个区间内的所有数按位或运算的和小于v 找出子区间的最大长度

思路:

我们可以从最高有效位往最低有效为看 用 vi 表示 v 的第i位 ai bi 同理

如果vi == 0 && ai == 0 && bi == 0 那么我们跳到下一位继续看

如果vi == 1 && ai == 0 && bi == 0 那么答案就是 b - a + 1 因为 将a - b 的所有数按位或起来的值肯定小于 v' (v' = 将v的第i位边为0, 小于i的所有位都变为1) 并且 v' < v

如果 vi == 0 && ai == 0 && bi == 1

那么我们可以将bi 变为0 然后将小于i的b的所有位都变为1 再往下一位看 这样的操作相当于缩小了b的范围,对答案没有影响

如果vi == 1 && ai == 1 && bi == 1

显然 我们可以将 vi ai bi 都变为0 然后看下一位操作 是没有影响的

如果vi == 0 && ai == 1 && bi == 1 那么此时答案显然为0 因为a > v

如果vi ==1 && ai == 0 && bi == 1

如果此时 vi的低位都为1 那么答案就是 b - a + 1

如果不是 我们可以 令c = 将vi 变为0 然后所有低位都变为1 答案为 c - a + 1

或者 我们 可以将 a 变成 c + 1 然后 三个数的第i位都变为0 继续找下去

为什么将a 变成 c + 1 而不考虑 c + 1 一下的数

因为 c | c + 1 必然大于等于v 而 等于的情况 就是 b - a + 1 已经特判过

 #include <bits/stdc++.h>

 using namespace std;

 #define ll long long

 int t;

 ll a, b, v;

 inline ll work(ll a, ll b, ll v, int i)
{
if (i == -)
return 1ll; ll D = (1ll << i) - ; bool ai = a & (D + ), bi = b & (D + ), vi = v & (D + ); if (vi && !ai && !bi)
return b - a + ;
if (!vi && ai && bi)
return ;
if (vi && ai && bi)
return work(a & D, b & D, v & D, i - );
if (!vi && !ai && !bi)
return work(a, b, v, i - );
if (!vi && !ai && bi)
return work(a, (1ll << i) - , v, i - ); if (v == ((1ll << (i + )) - ))
return b - a + ; ll c = (1ll << i) - ;
return max(c - a + , work(, b & D, v & D, i - ));
} int main()
{
#ifdef LOCAL
freopen("Test.in", "r", stdin);
#endif
scanf("%d", &t);
while (t--)
{
scanf("%lld%lld%lld", &a, &b, &v);
printf("%lld\n", work(a, b, v, ));
}
return ;
}

K:League of Demacia

题意:给定一个原点,给定一条边长为z的线段,使得原点为中点,角度不定。从该线段两端点向同一方向画出两条射线,使得这一区域的点超过m个。

思路:显然我们可以枚举每一个点在射线上的情况,然后o(n)枚举每个点的情况。确定某一点是否在区域内可通过向量的数量积与z/2的比较以及向量积来确定是否为同一方向。

 #include<bits/stdc++.h>

 using namespace std;

 #define N 1010

 const double eps = 1e-;

 inline int sgn(double x)
{
if(fabs(x) < eps) return ;
else if(x > ) return ;
else return -;
} struct Point{
double x, y;
inline Point(){}
inline Point(double x, double y) : x(x), y(y){} inline void input()
{
scanf("%lf %lf",&x, &y);
} inline Point operator - (const Point &b) const
{
return Point(x - b.x, y - b.y);
} inline double operator ^ (const Point &b) const
{
return x * b.y - y * b.x;
} inline double operator * (const Point &b) const
{
return x * b.x + y * b.y;
} inline Point operator + (const Point &b) const
{
return Point(x + b.x, y + b.y);
} inline Point operator / (const double &k) const
{
return Point(x / k, y / k);
} inline double distance(const Point &b) const
{
return hypot(x - b.x, y - b.y);
} inline Point rotate(Point p, double angle)
{
Point v = (*this) - p;
double c = cos(angle), s = sin(angle);
return Point(p.x + v.x * c - v.y * s, p.y + v.x * s + v.y * c);
}
}P[N]; int n, m;
double z; int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d %d %lf",&n, &m, &z);
double r = z / ;
for(int i = ; i <= n; ++i)
{
P[i].input();
}
bool flag = false;
for(int i = ; i <= n; ++i)
{
Point a = P[i];
double d = a.distance(Point(, ));
if(sgn(d) == ) a = Point(, );
else if(sgn(d - r) <= ) a = P[i];
else a = P[i].rotate(Point(, ), acos(r / d)); a = a / a.distance(Point(, ));
int cnt = ;
for(int j = ; j <= n; ++j)
{
if(i == j) continue;
double tmp = fabs(P[j] * a);
if(sgn(tmp - r) <= && sgn(a ^ P[j]) <= ) cnt++;
if(cnt >= m) break;
}
if(cnt >= m)
{
flag = true;
break;
}
}
puts(flag ? "Yes" : "No"); }
return ;
}

L:Lazy Teacher

题意:对一个nm的矩阵填色,一共有k个颜色,相邻的方块不能同一种颜色,求填色方案。

思路:首先注意到n很小,其次当我们按顺序填方格时,影响这一方格以及接下来的方格的只会是前5块,因此我们只用记录前5块方格即可。因此对于每一个长度为6的方块实际上最多用到6种颜色,我们将其离散化后,那么最远的方块p1<1,p2<2,p3<3,p4<4,p5<5

然后我们可以枚举当前要填充颜色的方块的颜色,从0-5,其中5代表和前面5块互不相同个颜色,然后搜索一下(或者说dp?),最后剪剪枝。

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long ll;

 const int MOD = 1e9 + ;

 #define M 10010

 int val[], pos[];
ll dp[][M][][][][]; int limit;
int n, m, k; inline void update()
{
memset(val, , sizeof val);
for (int i = , color = ; i < ; ++i)
{
if (val[pos[i]] != )
{
pos[i] = val[pos[i]] - ;
}
else
{
val[pos[i]] = color;
pos[i] = color - ;
color++;
}
}
} inline ll solve(int x, int y, int p2, int p3, int p4, int p5)
{
if (x == n) return solve(, y + , p2, p3, p4, p5);
if (y == m) return ;
if (dp[x][y][p2][p3][p4][p5] != -) return dp[x][y][p2][p3][p4][p5];
int res = ;
int up;
if (n == )
{
up = ;
}
else if (n == )
{
up = p2;
}
else if (n == )
{
up = p3;
}
else if (n == )
{
up = p4;
}
else if (up = )
{
up = p5;
}
for (int color = ; color < limit; ++color)
{
if (color == up && y != ) continue;//up
if (color == p5 && x != ) continue;//left
pos[] = p2, pos[] = p3, pos[] = p4, pos[] = p5, pos[] = color;
update();//离散化
res = (res + (color == ? k - : ) * solve(x + , y, pos[], pos[], pos[], pos[])) % MOD;//5 means new color
}
dp[x][y][p2][p3][p4][p5] = res;
return res;
} int main()
{
int t;
scanf("%d", &t);
while (t--)
{
scanf("%d %d %d", &n, &m, &k);
limit = min(k, );
memset(dp, -, sizeof dp);
ll ans = solve(, , , , , );
printf("%lld\n", ans);
}
return ;
}

M:Greedy Pirate

题意:给出一棵树,n - 1条边,一条边上两个权值,然后每次询问u -> v  问 从 u - > v的最大花费,每条边可以走两次

思路:显然 答案是所有边权和减去 终点到LCA的权值和 减去 LCA 到 起点的权值和

 #include<bits/stdc++.h>

 using namespace std;

 const int maxn = ;
const int DEG = ; typedef long long ll;
int n; struct Edge{
int to,nxt;
int w1,w2;
inline Edge(){}
inline Edge(int to,int nxt,int w1,int w2):to(to),nxt(nxt),w1(w1),w2(w2){}
}edge[maxn << ]; int head[maxn],tot; inline void addedge(int u,int v, int w1, int w2)
{
edge[tot] = Edge(v,head[u],w1,w2);
head[u] = tot++;
} int fa[maxn][DEG];
ll dis1[maxn];// from fa
ll dis2[maxn];// to fa
int deg[maxn]; void init()
{
tot = ;
memset(dis1, , sizeof dis1);
memset(dis2, , sizeof dis2);
memset(head, -, sizeof head);
} inline void BFS(int root)
{
queue<int>q;
deg[root] = ;
fa[root][] = root;
q.push(root);
while(!q.empty())
{
int tmp = q.front();
q.pop();
for(int i = ; i < DEG; ++i)
{
fa[tmp][i] = fa[fa[tmp][i - ]][i - ];
}
for(int i = head[tmp]; ~i; i = edge[i].nxt)
{
int v = edge[i].to;
if(v == fa[tmp][]) continue;
dis1[v] = dis1[tmp] + edge[i].w1;
dis2[v] = dis2[tmp] + edge[i].w2;
deg[v] = deg[tmp] + ;
fa[v][] = tmp;
q.push(v);
}
}
} int LCA(int u,int v)
{
if(deg[u] > deg[v]) swap(u, v);
int hu = deg[u], hv = deg[v];
int tu = u;
int tv = v;
for(int det = hv - hu, i = ; det; det >>= , ++i)
{
if(det & )
tv = fa[tv][i];
}
if(tu == tv) return tu;
for(int i = DEG - ; i >= ; --i)
{
if(fa[tu][i] == fa[tv][i]) continue;
tu = fa[tu][i];
tv = fa[tv][i];
}
return fa[tu][];
} int main()
{
int t;
scanf("%d",&t);
while(t--)
{
init();
scanf("%d",&n);
ll sum = ;
for(int i = ; i < n; ++i)
{
int u, v, w1, w2;
scanf("%d %d %d %d",&u, &v, &w1, &w2);
sum += w1 + w2;
addedge(u, v, w1, w2);
addedge(v, u, w2, w1);
}
BFS();
int q;
scanf("%d",&q);
while(q--)
{
int u,v;
scanf("%d %d",&u,&v);
int root = LCA(u,v);
ll ans = sum - (dis2[v] - dis2[root] + dis1[u] - dis1[root]);
printf("%lld\n",ans);
}
}
return ;
}

ACM ICPC, Amman Collegiate Programming Contest (2018) Solution的更多相关文章

  1. ACM ICPC, JUST Collegiate Programming Contest (2018) Solution

    A:Zero Array 题意:两种操作, 1 p v  将第p个位置的值改成v  2  查询最少的操作数使得所有数都变为0  操作为可以从原序列中选一个非0的数使得所有非0的数减去它,并且所有数不能 ...

  2. ACM ICPC, Damascus University Collegiate Programming Contest(2018) Solution

    A:Martadella Stikes Again 水. #include <bits/stdc++.h> using namespace std; #define ll long lon ...

  3. [ACM International Collegiate Programming Contest, Amman Collegiate Programming Contest (2018)]

    https://codeforces.com/gym/101810 A. Careful Thief time limit per test 2.5 s memory limit per test 2 ...

  4. GYM101810 ACM International Collegiate Programming Contest, Amman Collegiate Programming Contest (2018) M. Greedy Pirate (LCA)

    题意:有\(n\)个点,\(n-1\)条边,每条边正向和反向有两个权值,且每条边最多只能走两次,有\(m\)次询问,问你从\(u\)走到\(v\)的最大权值是多少. 题解:可以先在纸上画一画,不难发现 ...

  5. ACM International Collegiate Programming Contest, Tishreen Collegiate Programming Contest (2018) Syria, Lattakia, Tishreen University, April, 30, 2018

    ACM International Collegiate Programming Contest, Tishreen Collegiate Programming Contest (2018) Syr ...

  6. German Collegiate Programming Contest 2018​ B. Battle Royale

    Battle Royale games are the current trend in video games and Gamers Concealed Punching Circles (GCPC ...

  7. 18春季训练01-3/11 2015 ACM Amman Collegiate Programming Contest

    Solved A Gym 100712A Who Is The Winner Solved B Gym 100712B Rock-Paper-Scissors Solved C Gym 100712C ...

  8. German Collegiate Programming Contest 2018​ C. Coolest Ski Route

    John loves winter. Every skiing season he goes heli-skiing with his friends. To do so, they rent a h ...

  9. ACM Amman Collegiate Programming Contest(7.22随机组队娱乐赛)

    题目链接 https://vjudge.net/contest/240074#overview 只写一下自己做的几个题吧 /* D n^2的暴力dp怎么搞都可以的 这里先预处理 i到j的串时候合法 转 ...

随机推荐

  1. 第三篇:基于K-近邻分类算法的手写识别系统

    前言 本文将继续讲解K-近邻算法的项目实例 - 手写识别系统. 该系统在获取用户的手写输入后,判断用户写的是什么. 为了突出核心,简化细节,本示例系统中的输入为32x32矩阵,分类结果也均为数字.但对 ...

  2. Nginx.conf 配置文件详细说明

    在此记录下Nginx服务器nginx.conf的配置文件说明, 部分注释收集与网络. #运行用户user www-data;    #启动进程,通常设置成和cpu的数量相等worker_process ...

  3. CSS3 Transform变形(2D转换)

    Transform:对元素进行变形:Transition:对元素某个属性或多个属性的变化,进行控制(时间等),类似flash的补间动画.但只有两个关键贞.开始,结束.Animation:对元素某个属性 ...

  4. JS-点和中括号

    今天上午做一个很low的小练习,代码写完了想要封装重复利用来着 可是憋屈啊,怎么都不对,在document.style.width这里,想把width变成参数可是用点的话,会报错说找不到点后边这个属性 ...

  5. 【BZOJ2164】采矿 树链剖分+线段树维护DP

    [BZOJ2164]采矿 Description 浩浩荡荡的cg大军发现了一座矿产资源极其丰富的城市,他们打算在这座城市实施新的采矿战略.这个城市可以看成一棵有n个节点的有根树,我们把每个节点用1到n ...

  6. 【BZOJ4282】慎二的随机数列 乱搞

    [BZOJ4282]慎二的随机数列 Description 间桐慎二是间桐家著名的废柴,有一天,他在学校随机了一组随机数列, 准备使用他那强大的人工智能求出其最长上升子序列,但是天有不测风云,人有旦夕 ...

  7. 在ListView中嵌套ListView的事件处理

    十分感谢此作者,以及作者的作者,让我卡了一星期的问题解决了!!http://blog.csdn.net/hutengfei0701/article/details/8956284谢谢http://my ...

  8. Unity3D 笔记二 3D模型基础

    一.3D模型基础 1.Hierarchy 显示的是界面上的游戏对象(GameObject),每个游戏对象都有.至少要有一个Camera,点击Camera就可以在Preview中看到摄像机的视角画面.每 ...

  9. PHP中文字数限制:中文字符串截取(mb_substr)

    一.中文截取:mb_substr() mb_substr( $str, $start, $length, $encoding ) $str,需要截断的字符串 $start,截断开始处,起始处为0 $l ...

  10. 二维坐标系极角排序的应用(POJ1696)

    Space Ant Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 3170   Accepted: 2029 Descrip ...