memset | 易学教程

机器任务

阅读更多关于机器任务

有两台机器 A，B 以及 K 个任务。机器 A 有 N 种不同的模式（模式0~N-1），机器 B 有 M 种不同的模式（模式0~M-1）。两台机器最开始都处于模式0。每个任务既可以在A上执行，也可以在B上执行。对于每个任务 i，给定两个整数 a[i] 和 b[i]，表示如果该任务在 A 上执行，需要设置模式为 a[i]，如果在 B 上执行，需要模式为 b[i]。任务可以以任意顺序被执行，但每台机器转换一次模式就要重启一次。求怎样分配任务并合理安排顺序，能使机器重启次数最少。输入格式输入包含多组测试数据。每组数据第一行包含三个整数 N, M, K。接下来k行，每行三个整数 i, a[i]和b[i]，i 为任务编号，从0开始。当输入一行为0时，表示输入终止。输出格式每组数据输出一个整数，表示所需的机器最少重启次数，每个结果占一行。数据范围 N,M<100,K<1000 0≤a[i]<N 0≤b[i]<M 输入样例： 5 5 10 0 1 1 1 1 2 2 1 3 3 1 4 4 2 1 5 2 2 6 2 3 7 2 4 8 3 3 9 4 3 0 输出样例： 3 # pragma GCC optimize(2) # include <bits/stdc++.h> using namespace std ; const int N = 105 , M =

create my own memset function in c

阅读更多关于 create my own memset function in c

问题 here is the prototype: void *memset(void *s, int c, size_t n) first im not sure if I have to return something because when I use the memset i do for example memset(str, 'a', 5); instead of str = memset(str, 'a', 5); here is where I am with my code: void *my_memset(void *b, int c, int len) { int i; i = 0; while(b && len > 0) { b = c; b++; len--; } return(b); } int main() { char *str; str = strdup("hello"); my_memset(str, 'a', 5); printf("%s\n", str); } I dont want to use array in this function

Why I never see the Hello text in Console in this program?

阅读更多关于 Why I never see the Hello text in Console in this program?

问题 This is the code I have, running on OS X Yosemite int main(int argc, char *argv[]){ while (1) { srand(time(NULL)); int r = rand(); printf("Allocating\n"); int *pi = malloc(5000000 * sizeof(int)); if(pi==NULL){ printf("Hello"); } memset(pi, r, 5000000 * sizeof(int)); } } So this program eventually stops running, last lines in Console I see being: Allocating Allocating Allocating Killed: 9 Korays-MacBook-Pro:hello2 koraytugay$ If malloc does not return NULL in this situation, when will it do?

[IOI2008]Island

阅读更多关于 [IOI2008]Island

题目链接首先，我们发现这是一个基环外向树森林，所以我们发现只有两种情况： 1. 1. 1 . 最长路径在一颗子树中。 2. 2. 2 . 最长路径分别在两颗子树中，通过基环相连。因此，我们考虑首先 d f s dfs d f s 找到这个环，然后对于环上的点跑 d p dp d p ，这样我们就解决了第一个情况。而对于第二种情况，我们首先破坏为链，发现我们的所求就是：我们定义 g [ i ] g[i] g [ i ] 表示以 i i i 为根的外向树的最长路径。 f [ x ] = m i n i = x − n + 1 x − 1 ( g [ i ] + g [ x ] + d i s [ i , x ] ) f[x]=min_{i=x-n+1}^{x-1}(g[i]+g[x]+dis[i,x]) f [ x ] = m i n i = x − n + 1 x − 1 ( g [ i ] + g [ x ] + d i s [ i , x ] ) 由于我们发现 d i s [ i , j ] = d i s [ i , k ] + d i s [ k , j ] dis[i,j]=dis[i,k]+dis[k,j] d i s [ i , j ] = d i s [ i , k ] + d i s [ k , j ] ，所以这个一定可以使用单调队列进行优化。考虑写成

Why does memset take an int instead of a char?

阅读更多关于 Why does memset take an int instead of a char?

问题 Why does memset take an int as the second argument instead of a char , whereas wmemset takes a wchar_t instead of something like long or long long ? 回答1: memset predates (by quite a bit) the addition of function prototypes to C. Without a prototype, you can't pass a char to a function -- when/if you try, it'll be promoted to int when you pass it, and what the function receives is an int . It's also worth noting that in C, (but not in C++) a character literal like 'a' does not have type char -

[HNOI2008]玩具装箱TOY

阅读更多关于 [HNOI2008]玩具装箱TOY

题目链接学过斜率优化的同学应该知道只是一道板子题，这里我们给出一个不同的解法：我们定义 f [ i ] f[i] f [ i ] 表示考虑到了第 i i i 个点的最小代价是多少，那么我们可以得出这个转移式子： f [ i ] = m i n j = 1 i ( f [ j ] + w [ j ] [ i ] ) f[i]=min_{j=1}^i(f[j]+w[j][i]) f [ i ] = m i n j = 1 i ( f [ j ] + w [ j ] [ i ] ) 其中 w [ j ] [ i ] = ( j − i + ∑ k = 1 j c [ k ] − L ) 2 w[j][i]=(j-i+\sum_{k=1}^j c[k]-L)^2 w [ j ] [ i ] = ( j − i + ∑ k = 1 j c [ k ] − L ) 2 看着像不太好优化的样子，但是实际上我们发现 f [ i ] f[i] f [ i ] 是凸的，换句话说 f [ i ] f[i] f [ i ] 的决策点具有单调性。这样我们考虑如果我们已经知道了一个状态 f [ i ] f[i] f [ i ] ，我们考虑它能更新哪些状态，不难发现，由于决策点具有单调性，那么我们可以二分一下它所影响的区间，具体我们画图来解释一下：一开始所有点的最优决策点：

[USACO08MAR]土地征用Land Acquisition

阅读更多关于 [USACO08MAR]土地征用Land Acquisition

题目链接首先我们按照长度从大到小排序，这样我们考虑宽就可以了，我们发现这样一个事情：其中我们发现红色的点可以直接被删去，以为它们一定会被两侧的点覆盖。于是我们的所求就是： f [ i ] = m i n j = 0 i − 1 ( f [ j ] + a [ j + 1 ] × b [ i ] ) f[i]=min_{j=0}^{i-1}(f[j]+a[j+1] \times b[i]) f [ i ] = m i n j = 0 i − 1 ( f [ j ] + a [ j + 1 ] × b [ i ] ) 然后我们发现 f [ i ] f[i] f [ i ] 是凸的，于是我们单调栈 + + + 二分就可以了，具体做法详见： [HNOI2008]玩具装箱TOY 代码实现： //Optimize # pragma GCC optimize("Ofast") //Head File # include <bits/stdc++.h> using namespace std ; # define il inline //Variable # define ll long long # define ull unsigned long long # define db double # define lb long double //Debug # define B

【线性规划和网络流24题】

阅读更多关于【线性规划和网络流24题】

（1）飞行员配对方案问题：二分图最大匹配。思路：略。 View Code 1 #include<cstdio> 2 #include<cstring> 3 #define MAXN 1010 4 int cx[MAXN], cy[MAXN]; 5 int first[MAXN], next[MAXN], v[MAXN], e; 6 bool vis[MAXN]; 7 inline void addEdge(int x, int y) { 8 v[e] = y; 9 next[e] = first[x]; 10 first[x] = e++; 11 } 12 int path(int x) { 13 int i; 14 int y; 15 for (i = first[x]; i != -1; i = next[i]) { 16 y = v[i]; 17 if (!vis[y]) { 18 vis[y] = true; 19 if (cy[y] == -1 || path(cy[y])) { 20 cx[x] = y; 21 cy[y] = x; 22 return 1; 23 } 24 } 25 } 26 return 0; 27 } 28 int main() { 29 int n, m; 30 int i; 31 int x, y; 32 int ans; 33 while

动态规划--背包

阅读更多关于动态规划--背包

1. 01背包：有 N 件物品和一个容量为 V 的背包。第 i 件物品的费用是 c[i]，价值是 w[i]。求解将哪些物品装入背包可使价值总和最大。　　对于这类问题我们我们定义f[i][j]表示在前i个物品中选总容量为j所能得到的最大价值为多少于是我们状态转移便是这样 f[i][j]=max(f[i][j],f[i-1][j-w[i]]+v[i]); int f[N][M]; void work() { memset(f,0,sizeof(f)); for(int i=1;i<=n;i++) for(int j=w[i];j<=m;j++) f[i][j]=max(f[i][j],f[i-1][j-w[i]]+v[i]); for(int i=1;i<=m;i++) ans=max(f[n][i],ans); printf("%d\n",ans); } 　　这样一来，我们的时间复杂度就是O(nm),空间复杂度为O(nm)，但我们发现f[i]的值只与f[i-1]有关,此时我们可以用滚动数组来优化空间到O(m),为f[j]=max(f[j],[j-w[i]]+v[i]);此时我们的j就要倒序枚举，因为j只会从比它小的j那转移。 int f[M]; void work() { memset(f,0,sizeof(f)); for(int i=1;i<=n;i++) for(int

[SCOI2009]迷路

阅读更多关于 [SCOI2009]迷路

题目链接看着好像很不可做的样子，那我们首先考虑一下这道题的弱化版：假设所有的边权等于 1 1 1 或 0 0 0 ，那么我们可以这么考虑这个矩阵： f [ k ] [ i ] [ j ] f[k][i][j] f [ k ] [ i ] [ j ] 表示从 i i i 到 j j j 的路径长度为 k k k 的条数是多少，那么我们考虑这样转移： f [ k ] [ i ] [ j ] = f [ k − 1 ] [ i ] [ t ] + f [ 1 ] [ t ] [ j ] f[k][i][j]=f[k-1][i][t]+f[1][t][j] f [ k ] [ i ] [ j ] = f [ k − 1 ] [ i ] [ t ] + f [ 1 ] [ t ] [ j ] ，我们发现这可以矩乘，于是我们就可以在 O ( n 3 l o g T ) O(n^3logT) O ( n 3 l o g T ) 的复杂度内解决这个问题。那么我们考虑边权不为 0 0 0 或 1 1 1 的情况，我们考虑拆点：将每一个点拆成 9 9 9 个点，我们考虑 z [ i ] [ j ] z[i][j] z [ i ] [ j ] 表示到点 i i i 的距离为 j j j 的点，因此我们发现 z [ i ] [ 0 ] z[i][0] z [ i ] [ 0 ] 是实际存在的点

订阅 memset