Given the condition: $ T(O(1)) = O(1)$ and $ T(n) \leq \sqrt{n}T(\sqrt{n}) + n$ . I need to solve this recurrence relation. The hardest part for me is the number of subproblems $ \sqrt{n}$ is not a constant, it’s really difficult to apply tree method and master theorem here. Any hint? My thought is that let $ c = \sqrt{n}$ such that $ c^2 = n$ so we have $ T(c^2) \leq cT(c) + c^2$ but I does not look good.

# Tag: relation

## Way to validate a parent/child relation

I have a rest endpoint for example `/user/{userId}/message/{messageId}`

I have the possibility to create both ID’s as I want.

How can I create `messageId`

and know the message is belong to this user, without checking in database or any service?

I think about hashing `userId`

and add the hash as prefix of `messageId`

.

## Is every attack against a weapon/shield a sunder attempt? (Also, Mountain Hammer relation to this)

The first question is self-explanatory, and if the answer is yes, is Mountain Hammer and it’s upgrades usable on such items without counting as sunder attempts? If not, can they be used instead of an attack in a sunder attampt?

## Recurrence relation for the number of “references” to two mutually recursive function

I was going through the Dynamic Programming section of Introduction to Algorithms(2nd Edition) by Cormen et. al. where I came across the following recurrence relations in the assembly line scheduling portion.

$ (1),(2),(3)$ are three relations as shown.

$ $ f_{1}[j] = \begin{cases} e_1+a_{1,1} &\quad\text{if } j=1\ \min(f_1[j-1]+a_{1,j},f_2[j-1]+t_{2,j-1}+a_{1,j})&\quad\text{if} j\geq2\ \end{cases}\tag 1$ $

Symmetrically,

$ $ f_{2}[j] = \begin{cases} e_2+a_{2,1} &\quad\text{if } j=1\ \min(f_2[j-1]+a_{2,j},f_1[j-1]+t_{1,j-1}+a_{2,j})&\quad\text{if} j\geq2\ \end{cases}\tag 2$ $

(where $ e_i,a_{i,j},t_{2,j-1}$ are constants for $ i=1,2$ and $ j=1,2,3,…,n$ )

$ $ f^\star=\min(f_1[n]+x_1,f_2[n]+x_2)\tag 3$ $

The text tries to find the recurrence relation of the number of times $ f_i[j]$ ($ i=1,2$ and $ j=1,2,3,…,n$ ) is referenced if we write a mutual recursive code for $ f_1[j]$ and $ f_2[j]$ . Let $ r_i(j)$ denote the number of times $ f_i[j]$ is referenced.

They say that,

From $ (3)$ ,

$ $ r_1(n)=r_2(n)=1.\tag4$ $

From $ (1)$ and $ (2)$ ,

$ $ r_1(j)=r_2(j)=r_1(j+1)+r_2(j+1)\tag 5$ $

**I could not quite understand how the relations of $ (4)$ and $ (5)$ are obtained from the three corresponding relations.**

Thought I could make out intuitively that as there is only one place where $ f_1[n]$ and $ f_2[n]$ are called, which is in $ f^\star$ , so probably in $ (4)$ we get the required relation.

But as I had not encountered such concept before I do not quite know how to proceed. I would be grateful if someone guides me with the mathematical prove of the derivation as well as the intuition, however I would prefer an alternative to mathematical induction as it is a mechanical cookbook method without giving much insight into the problem though (but if in case there is no other way out, then I shall appreciate mathematical induction as well provided the intuition is explained to me properly).

## closed form for the following recurrence relation

$ t(k,m,n) = \frac{m}{k}t(k-1,m-1,n-1)+ \frac{k-m}{k} t(k-2,m-1,n-1) + \frac{k-m}{k} $ , where $ k \geq m \geq n$

## Importance of space constructability in time space relation in complexity

I am reading Arora-Barak’s Complexity book. In Chapter 4, they state and prove the following theorem.

Why $ S$ should be space constructible? Wouldn’t all three containments of theorem hold, even if $ S$ is not space constructible?

My other question is about Remark 4.3, the book claims that if $ S$ is space constructible then you can make an $ NSPACE(S(n))$ machine halt on every sequence of non-deterministic choices by keeping a counter till $ 2^{O(S(n))}$ . I am not sure how we can keep such a counter in $ S(n)$ space. The space constructability of $ S$ implies that we can compute $ S(n)$ in $ O(S(n))$ space, not $ 2^{O(S(n))}$ in $ O(S(n))$ space.

## How to solve this recurrence relation using substitution method

Can anyone explain to me how to demonstrate that,

T (n, d) ≤ T (n − 1, d) + O(d) + d/n (O(dn) + T (n − 1, d − 1))

is solved by

T (n, d) ≤ bnd! (b is a constant)

using the substitution method?

I have done this but I don’t know if it is correct.

- T (n-1, d) ≤ b(n-1)d!
- O(d) ≤ bd
- d/n (O(dn) + T (n − 1, d − 1)) ≤ d/n (bnd + b(n-1)d(n-1)!)

## Time complexity of DFS and recurrence relation

Is it possible to compute time complexity of Depth First Search (recursive version) using a recurrence relation?

## What’s the recurrence relation of the following?

What would the recurrence relation of this algorithm be?

Would it be similar at all to the recurrence relation of a normal binary search?

## Modeling a three-way association with optional relation

## Business rules

I have three tables (`Parties`

, `Categories`

and `Products`

) which representing the following relationships:

- A
**product**is classified by zero-one-to-many**categories** - A
**category**classifies zero-one-or-many**products**

Then, I have the party relationships:

- A
**product**is classified by one-to-one**party** - A
**party**classifies one-to-many**products**

In other words, a product doesn’t have to be assigned a category.

## Design proposal

I have based my design on the proposal found here, but it’s not entirely applicable since want to enforce `party_id`

for both `Products`

and `Categories`

:

How to model a three-way association that involves Product, Category and Label?

## Question

Is the usage of the three-way association table correct in my proposal to avoid the risk of having the application layer assigning a product to a category without enforcing the `party_id`

?