> For the complete documentation index, see [llms.txt](https://coding-9.gitbook.io/untitled/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://coding-9.gitbook.io/untitled/dynamic-programming/dp-on-lis/1048.-longest-string-chain.md).

# 1048. Longest String Chain

## Problem Statement

<br>

You are given an array of `words` where each word consists of lowercase English letters.

`wordA` is a **predecessor** of `wordB` if and only if we can insert **exactly one** letter anywhere in `wordA` **without changing the order of the other characters** to make it equal to `wordB`.

* For example, `"abc"` is a **predecessor** of `"abac"`, while `"cba"` is not a **predecessor** of `"bcad"`.

A **word chain** is a sequence of words `[word1, word2, ..., wordk]` with `k >= 1`, where `word1` is a **predecessor** of `word2`, `word2` is a **predecessor** of `word3`, and so on. A single word is trivially a **word chain** with `k == 1`.

Return *the **length** of the **longest possible word chain** with words chosen from the given list of* `words`.

&#x20;

**Example 1:**

<pre><code><strong>Input: words = ["a","b","ba","bca","bda","bdca"]
</strong><strong>Output: 4
</strong><strong>Explanation: One of the longest word chains is ["a","ba","bda","bdca"].
</strong></code></pre>

**Example 2:**

<pre><code><strong>Input: words = ["xbc","pcxbcf","xb","cxbc","pcxbc"]
</strong><strong>Output: 5
</strong><strong>Explanation: All the words can be put in a word chain ["xb", "xbc", "cxbc", "pcxbc", "pcxbcf"].
</strong></code></pre>

**Example 3:**

<pre><code><strong>Input: words = ["abcd","dbqca"]
</strong><strong>Output: 1
</strong><strong>Explanation: The trivial word chain ["abcd"] is one of the longest word chains.
</strong>["abcd","dbqca"] is not a valid word chain because the ordering of the letters is changed.
</code></pre>

&#x20;

**Constraints:**

* `1 <= words.length <= 1000`
* `1 <= words[i].length <= 16`
* `words[i]` only consists of lowercase English letters.

## Intuition

```
Approach:

Issue was with comparator
a.size() <= b.size()   refer the section learnings

We treat this problem like LIS, where,
Just to write compare function,
Where we add the character check

Skipping extra character and reaching both at ends
```

### Links

<https://leetcode.com/problems/longest-string-chain/description/?envType=daily-question&envId=2023-09-23>

### Video Links

<https://www.youtube.com/watch?v=YY8iBaYcc4g&ab_channel=takeUforward>

### Approach 1:

```
```

{% code title="C++" lineNumbers="true" %}

```cpp
class Solution {
public:
    static bool comp(string &a, string &b){
        return a.size() < b.size();
    }

    bool compare(string& s1, string& s2){
        if(s1.size() != s2.size() + 1) return false;
        int first = 0, second = 0;

        while(first < s1.size()){
            if(s1[first] == s2[second]){
                first ++; second ++;
            }
            else 
                first ++;
        }
        if(first == s1.size() and second == s2.size()) 
            return true;
        return false; 
    }

    int longestStrChain(vector<string>& arr) {
        int n = arr.size();
        sort(arr.begin(), arr.end(),comp);
        vector<int> dp(n,1);
        int maxi = 1;
        
        for(int i=0; i<n; i++){
            for(int prev = 0; prev<i; prev++){
                if( compare(arr[i], arr[prev]) and 1 + dp[prev] > dp[i]){
                    dp[i] = 1 + dp[prev];
                }
            }
            
            if(dp[i] > maxi)
                maxi = dp[i];
        }
        return maxi;
    }
    
};
```

{% endcode %}

### Approach 2:

```
```

{% code title="C++" lineNumbers="true" %}

```cpp
```

{% endcode %}

### Approach 3:

```
```

{% code title="C++" lineNumbers="true" %}

```cpp
```

{% endcode %}

### Approach 4:

```
```

{% code title="C++" lineNumbers="true" %}

```cpp
```

{% endcode %}

### Similar Problems

###