Solution:
First, for each + operation, we only need count the number of subsequences which include this operation.
Let us assume the i-th operation is +, and the value of it is a[i]. If it be included by one of subsequence, then all the - operations in this process will not remove this a[i].
So that, for each - operation, it must be one of the two cases below:
1. It's j-th step, and j<i. For this case it will never remove a[i].
2. It's j-th step, and j>i. For this case, there at least be one value in the set which is smaller than a[i].
We define dp[j][k] to represent that: after j steps, there are k numbers in the set which is smaller than a[i]. Consider the step j can be applied or not applied. So, we have: $$\begin{cases}
dp[j][k]=dp[j-1][k]+dp[j-1][k], &(a[j]>a[i])\\
dp[j][k]=dp[j-1][k]+dp[j-1][k+1], &(a[j]=-1)\\
dp[j][k]=dp[j-1][k]+dp[j-1][k-1], &(a[j]<a[i])\\
\end{cases}
$$which means:
If step j is +, and the value is larger than a[i], then this operation will not affect k.
If step j is -, we get dp[j-1][k] possibilities for not apply this operation; and get dp[j-1][k+1] possibilities for apply this operation.
If step j is +, and the value is smaller than a[i], we get dp[j-1][k-1] possibilities if we apply this operation. Also, we can choose not to apply it.
Now, we get two special cases:
- For a[j]=a[i]. Based on the QA for this problem. We can sort by index and remove the smaller one firstly.
- For j<i and k=0 and a[j]=-1. Because the j is in front of i. So, it will not affect a[i] anyway. So, dp[j][0]=dp[j-1][0]+dp[j-1][0]+dp[j-1][k+1]. In another words, for k=0, it does not matter whether apply or not.
At the same time, we found that, we can compress the states. So, in the code, we just define dp[k] is enough for us.
Code:
Java
C++
