int ways(int n, int a[], int k)
{
if(n<0 || k<0) return 0;
if(n == 0) return 1;
if(k == 0) return 0;
return ways(n, a, k-1) + ways(n-a[k-1], a, k);
}
int ways(int n)
{
if(dp[n]) return dp[n];
int val=(ways(n-2)+ways(n-1))%MOD;
dp[n]=val;
return dp[n];
}
ll ways(ll coderpos, ll linepos, ll bugpos){
if(bugpos > maxbugs or coderpos > coders){
return 0;
} else if(linepos == linesneeded){
return 1;
} else if(coderpos == coders){
return 0;
}
return ways(coderpos + 1, linepos, bugpos)
+ ways(coderpos, linepos + 1, bugpos + bugsperline[coderpos]);
}
long long ways(long long pos = 0, long long sum = 0, long long easy = 1000000000, long long hard = 0, long long taken = 0){
if(pos == problems){
if(sum >= min and sum <= max and hard - easy >= range and taken >= 2){
return 1;
} else {
return 0;
}
}
return ways(pos + 1, sum + diff[pos], std::min(easy, diff[pos]), std::max(hard, diff[pos]), taken + 1) +
ways(pos + 1, sum, easy, hard, taken);
}
int ways(int n)
{
if(n==1)
return 1;
if(n==2)
return 2;
if(n==3)
return 4;
else if(n>3)
return ways(n-1)+ways(n-2)+ways(n-3);
}
int main() {
const long M = 1000000007;
int n, k, d;
scanf("%d %d %d\n", &n, &k, &d);
std::vector<std::pair<long long, long long> > ways(n + 1);
ways[0].first = 1;
ways[0].second = 0;
for(int p = 1; p <= n; p++) {
for(int b = 1; b <= k && b <= p; b++) {
if(b < d) {
ways[p].first += ways[p - b].first;
ways[p].first %= M;
ways[p].second += ways[p - b].second;
ways[p].second %= M;
}
else {
ways[p].second += (ways[p - b].first + ways[p - b].second);
ways[p].second %= M;
}
}
}
printf("%lld\n", ways[n].second);
return 0;
}
uint64_t cways(uint64_t length, uint64_t a, uint64_t b){
uint64_t c = 0;
for(uint64_t i = a; i <= b; ++i){
c += ways(length, i);
}
return c - (b - a + 1);
}
int main()
{
int n,S;
scanf("%d",&n);
S=ways(n);
printf("%d",S);
}
int main()
{
int m;
int t;
int n;
printf("Number of coins? ");
scanf("%d", &m);
int coin[m], i;
for(i=0; i<m; i++)
{
printf("coin? ");
scanf("%d", &coin[i]);
}
printf("---- your requests --- \n");
while(1)
{
printf("amount? exit(0) ");
scanf("%d", &n);
if (!n)
{
break;
}
printf("%d\n", ways(n, coin, m));
}
return 0;
}
int main(){
auto primes = pe::PrimeSieve<2000>::make_vector();
int i = 10;
while(ways(i, primes) < 5000)
i++;
std::cout << i << std::endl;
return 0;
}
int main()
{
memset(memo, -1, sizeof(memo));
int n;
while (scanf("%d", &n) != EOF)
printf("%d\n", ways(0, n));
return 0;
}
int ways(int n,int m)
{
if(n==0 || m==0)
{
return 1;
}
return ways()
}
int main()
{
int i;
printf("Hi, Do you wanna know how much different\nway that you can climb\n");
printf("Enter stair numbers>>");
scanf("%d",&i);
printf("In Total => you have %d different ways.\n",ways(i));
return 0;
}
int stairsWays(int n){
if(n<1) return 0;
vector <int > ways(n);
ways[0] = 1;
ways[1] = ways[0]+1;
ways[2] = ways[0]+ways[1]+1;
int i=3;
while(i<n)
ways[i] = ways[i-1]+ways[i-2]+ways[i-3];
return ways[n-1];
}
int ways(int type, int value)
{
// 1 jeito: Não usa nenhuma moeda
if (value == 0)
return 1;
// Não existem moedas negativas
if (value < 0)
return 0;
// Só existe 5 moedas
if (type >= 5)
return 0;
// Já estava pré-calculado
if (memo[type][value] != -1)
return memo[type][value];
memo[type][value] = ways(type + 1, value) + ways(type, value - coinValue[type]);
return memo[type][value];
}
void CoinSums()
{
uint64_t mod = 1000000007;
auto amount = 200;
std::vector<int> coin_sizes = {1, 2, 5, 10, 20, 50, 100, 200};
std::vector<uint64_t> ways(amount + 1, 0);
ways[0] = 1;
for (auto coin : coin_sizes) {
for (auto j = coin; j <= amount; ++j) {
ways[j] = (ways[j] + ways[j - coin]) % mod;
}
}
std::cout << ways[amount] << std::endl;
}
int main()
{
int coin[7]= {1,2,5,10,20,50,100},i,j,x,c;
x=100;
vector<long long> ways(x+1,0);
ways[0]=1;
for (i=0; i<7; i++)
{
c=coin[i];
for (j=c; j<=x; j++)
ways[j]+=ways[j-c];
}
cout<<ways[100]<<endl;
}
int solve31() {
int target = 200;
vector<int> coins = { 1, 2, 5, 10, 20, 50, 100, 200 };
vector<int> ways( target + 1, 0 );
ways[0] = 1;
for( int coin : coins ) {
for( int j = coin; j <= target; j++ ) {
ways[j] += ways[j - coin];
}
}
return ways[200];
}
int uniquePaths(int m, int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if(m==0||n==0) return 0;
vector<vector<int> > ways(m,vector<int>(n,0));
for(int i=0;i<m;++i) ways[i][0]=1;
for(int j=0;j<n;++j) ways[0][j]=1;
for(int i=1;i<m;++i){
for(int j=1;j<n;++j){
ways[i][j]=ways[i-1][j]+ways[i][j-1];
}
}
return ways[m-1][n-1];
}
int numDecodings(string s) {
if(s.empty() || s == "0")
return 0;
vector<int> ways(s.size()+1, 1);
for(int i = s.size()-1; i >= 0; --i)
{
if(s[i] == '0')
ways[i] = 0;
else
ways[i] = ways[i+1];
if(i+1 < s.size() && ((s[i] == '1') || (s[i] == '2' && s[i+1] - '0' <= 6)))
ways[i] += ways[i+2];
}
return ways[0];
}
long count (int tsize)
{
std::vector<long> ways(size + 1);
int min = 1;
int max = size / tsize;
int nways = 0;
for (int i = 0; i < tsize; i++)
{
ways[i] = 1;
}
for (int i = tsize; i <= size; ++i)
{
ways[i] = ways[i-1] + ways[i - tsize];
}
return ways[size] - 1;
}
int numDecodings(string s) {
if(s.size() == 0) return 0;
if(s[0] == '0') return 0;
for(int i = 0; i != s.size(); ++i){
if(s[i] < '0' || s[i] > '9') return 0;
}
vector<int> ways(s.size()+1,0);
ways[0] = 1;
ways[1] = 1;
for(int i = 2; i <= s.size(); ++i){
int v1 = s[i-1] - '0';
int v2 = (s[i-1] - '0') + 10 * (s[i-2] - '0');
if(v1 != 0) ways[i] += ways[i-1];
if(v2 > 9 && v2 <= 26) ways[i] += ways[i-2];
}
return ways[s.size()];
}
int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if(obstacleGrid.size()==0||obstacleGrid[0].size()==0) return 0;
int n=obstacleGrid.size(),m=obstacleGrid[0].size();
vector<vector<int> > ways(n,vector<int>(m,0));
ways[0][0]=1-obstacleGrid[0][0];
for(int i=1;i<n;++i) ways[i][0]=(1-obstacleGrid[i][0])*ways[i-1][0];
for(int j=1;j<m;++j) ways[0][j]=(1-obstacleGrid[0][j])*ways[0][j-1];
for(int i=1;i<n;++i){
for(int j=1;j<m;++j){
if(obstacleGrid[i][j]==0)
ways[i][j]=ways[i-1][j]+ways[i][j-1];
}
}
return ways[n-1][m-1];
}
int numDecodings(string s) {
int size = s.size();
if(!size)
return 0;
char pre = s[0];
vector<int> ways(size);
if(s[0] != '0')
ways[0] = 1;
else
return 0;
for(int i = 1; i < size; i++) {
if(s[i] == '0') {
if(s[i-1] == '1' || s[i-1] == '2') {
if(i>1) {
ways[i] = ways[i-2];
}
else
ways[i] = 1;
}
else {
return 0;
}
}
else {
if(s[i-1] == '0' || s[i-1] > '2') {
ways[i] = ways[i-1];
}
else {
if(s[i-1] == '2' && s[i] >='7') {
ways[i] = ways[i-1];
}
else {
ways[i] = ways[i-1];
if(i > 1) {
ways[i] += ways[i-2];
}
else {
ways[i]++;
}
}
}
}
}
return ways[size - 1];
}
int numDecodings(string s) {
if(s.size() == 0)
return 0;
vector<int> ways(s.size() + 2,1);//多出来的两个作为占位符，避免程序内判断是否超过size
for(int i = s.size() - 1; i >= 0; --i)
{
//self
if(s[i] == '0')
ways[i] = 0;
else
ways[i] = ways[i+1];
//self and next
if( i + 1 < s.size() && ((s[i] == '1' || (s[i] == '2' && s[i + 1] <= '6')))) {
ways[i] += ways[i + 2];
}
}
return ways[0];
}
int solve77() {
int limit = 100;
auto primes = sieve( 100 );
vector<int> ways( limit, 0 );
ways[0] = 1;
for( int prime : primes ) {
for( int j = prime; j <= limit; ++j ) {
ways[j] += ways[j - prime];
}
}
for( int i = 0; i < limit; ++i ) {
if( ways[i] > 5000 ) {
return i;
}
}
return -1;
}
int Solution::uniquePaths(int m, int n)
{
vector<int> ways(m);
vector<int> ways1;
for (int j = n - 1; j >= 0; j--)
{
ways = vector<int>(m, 0);
if (j == n - 1)
ways[m - 1] = 1;
for (int i = m - 1; i >= 0; i--)
{
if (i + 1 < m)
ways[i] += ways[i + 1];
if (j + 1 < n)
ways[i] += ways1[i];
}
ways1 = ways;
}
return ways[0];
}
string findShortestWay(vector<vector<int>>& maze, vector<int>& ball, vector<int>& hole) {
int m = maze.size(), n = maze[0].size();
vector<vector<int> > dis(m, vector<int>(n, INT_MAX));
vector<vector<string> > ways(m, vector<string>(n, ""));
priority_queue<pair<int, int>, vector<pair<int,int> >,cmp> pq;
pq.push({ball[0]*n+ball[1], 0});
dis[ball[0]][ball[1]] = 0;
while(!pq.empty()){
auto cur = pq.top();
pq.pop();
int x = cur.first/n, y = cur.first%n;
if(cur.second > dis[x][y]) continue;
if(x==hole[0] && y==hole[1]) return ways[x][y];
for(int i = 0; i < 4; ++i){
int xNew = x, yNew = y, step = 0;
string trys = ways[x][y]+dirStr[i];
while(xNew+dir[i].first>=0 && yNew+dir[i].second>=0 && xNew+dir[i].first<m && yNew+dir[i].second<n && maze[xNew+dir[i].first][yNew+dir[i].second]!=1){
xNew += dir[i].first;
yNew += dir[i].second;
++step;
if(xNew==hole[0] && yNew==hole[1]) break;
}
//xNew -= dir[i].first;
//yNew -= dir[i].second;
if(step==0) continue;
if(dis[x][y]+step < dis[xNew][yNew]){
dis[xNew][yNew] = dis[x][y]+step;
ways[xNew][yNew] = trys;
pq.push({xNew*n+yNew, dis[xNew][yNew]});
}
else if(dis[x][y]+step == dis[xNew][yNew]){
if(trys < ways[xNew][yNew]) ways[xNew][yNew] = trys;
}
}
}
return "impossible";
}
int findTargetSumWays(vector<int>& nums, int S) {
/**
* DP Formula:
*
* Let ways[i][j] denotes the number of ways to sum up j using
* the first i elements.
*
* ways[i][j] = ways[i - 1][j - num[i]] + # the sum of the first i - 1 elements is j + num[i]
* ways[i - 1][j + nums[i]] # the sum of the first i - 1 elements is j - num[i]
*/
int count_num = nums.size();
if (count_num == 0) {
return 0;
}
std::vector<std::unordered_map<int, int>> ways(
count_num, std::unordered_map<int, int>());
ways[0][nums[0]] += 1;
ways[0][-nums[0]] += 1;
for (int i = 1 ; i < count_num ; ++i) {
int num = nums[i];
for (const auto& pair : ways[i - 1]) {
int sum = pair.first;
int way = pair.second;
ways[i][sum + num] += way;
ways[i][sum - num] += way;
}
}
return ways[count_num - 1][S];
}
