class
Exchange {
public
:
int
countWays(vector<
int
> penny,
int
n,
int
aim) {
if
(penny.empty()||n ==
0
)
return
0
;
vector
int
> > dp(n,vector<
int
>(aim+
1
));
for
(
int
i =
0
;i < n;i++) {
dp[i][
0
] =
1
;
}
for
(
int
j =
1
;j < aim+
1
;j++) {
dp[
0
][j] = j%penny[
0
] ==
0
?
1
:
0
;
}
for
(
int
i =
1
;i < n;i++) {
for
(
int
j =
1
;j < aim+
1
;j++) {
dp[i][j] = (j-penny[i]) >=
0
?(dp[i-
1
][j] + dp[i][j-penny[i]]):dp[i-
1
][j];
}
}
return
dp[n-
1
][aim];
}
};
class
Exchange {
public
:
int
countWays(vector<
int
> penny,
int
n,
int
aim) {
vector<
int
> dp(aim +
1
);
for
(
int
i =
0
; i <= aim; i++)
if
(i % penny[
0
] ==
0
)
dp[i] =
1
;
for
(
int
i =
1
; i < n; i++)
for
(
int
j =
1
; j <= aim; j++)
if
( j >= penny[i])
dp[j] += dp[j - penny[i]];
return
dp[aim];
}
};
class
GoUpstairs {
public
:
int
countWays(
int
n) {
vector<
int
> dp(
2
,
0
);
dp[
0
] =
1
;
dp[
1
] =
2
;
int
temp;
for
(
int
i =
3
;i <= n;i++) {
temp = dp[
0
];
dp[
0
] = dp[
1
];
dp[
1
] = (dp[
1
]+temp)%
1000000007
;
}
return
dp[
1
]%
1000000007
;
}
};
class
MinimumPath {
public
:
int
getMin(vector
int
> > map,
int
n,
int
m) {
vector<
int
> dp(m,
0
);
dp[
0
] = map[
0
][
0
];
for
(
int
i =
1
,j =
0
;i < m;i++,j++) {
dp[i] = map[
0
][i]+dp[j];
}
for
(
int
i =
1
;i < n;i++) {
dp[
0
] += map[i][
0
];
for
(
int
j =
1
;j < m;j++) {
dp[j] = min(dp[j],dp[j-
1
])+map[i][j];
}
}
return
dp[m-
1
];
}
};
class
LCS {
public
:
int
findLCS(string A,
int
n, string B,
int
m) {
if
(A.empty()||n==
0
||B.empty()||m==
0
)
return
0
;
vector
int
> > dp(n,vector<
int
>(m));
for
(
int
i =
0
;i < m;i++) {
if
(A[
0
] == B[i]) {
for
(
int
j = i;j < m;j++)
dp[
0
][j] =
1
;
break
;
}
}
for
(
int
i =
0
;i < n;i++) {
if
(B[
0
] == A[i]) {
for
(
int
j = i;j < n;j++)
dp[j][
0
] =
1
;
break
;
}
}
for
(
int
i =
1
;i < n;i++) {
for
(
int
j =
1
;j < m;j++) {
if
(A[i] == B[j])
dp[i][j] = dp[i-
1
][j-
1
]+
1
;
else
dp[i][j] = max(dp[i-
1
][j],dp[i][j-
1
]);
}
}
return
dp[n-
1
][m-
1
];
}
};
class
LCS {
public
:
int
findLCS(string A,
int
n, string B,
int
m) {
vector
int
> > dp(n+
1
,vector<
int
>(m+
1
,
0
));
for
(
int
i =
1
;i<=n ;++i){
for
(
int
j=
1
; j<=m; ++j){
if
(A[i-
1
] == B[j-
1
]){
dp[i][j] = dp[i-
1
][j-
1
]+
1
;
}
else
{
dp[i][j] = max( dp[i-
1
][j] ,dp[i][j-
1
]);
}
}
}
return
dp[n][m];
}
};
class
Backpack {
public
:
int
maxValue(vector<
int
> w, vector<
int
> v,
int
n,
int
cap) {
if
(w.empty()||v.empty()||n==
0
||cap==
0
)
return
0
;
vector
int
> > dp(n,vector<
int
>(cap+
1
));
for
(
int
j =
1
;j < cap+
1
;j++) {
dp[
0
][j] = w[
0
] <= j?v[
0
]:
0
;
}
for
(
int
i =
0
;i < n;i++) {
dp[i][
0
] =
0
;
}
for
(
int
i =
1
;i < n;i++) {
for
(
int
j =
1
;j < cap+
1
;j++) {
if
(w[i] > j)
dp[i][j] = dp[i-
1
][j];
else
dp[i][j] = max(dp[i-
1
][j],v[i]+dp[i-
1
][j-w[i]]);
}
}
return
dp[n-
1
][cap];
}
};
推荐博文:
经典排序算法的C++实现